Storage unit subsystem

ABSTRACT

When receiving a write request from a processor, a control unit checks the condition of existence (or the presence/absence) in a cache for information necessary for generation of an updated value of a parity record, receives write data and reports the completion of the write request to the processor. In asynchronism with the write request from the processor, the control unit performs a load process for that information among the information necessary for generation of the updated value of the parity record which may be prepared in asynchronism with the write request from the processor and a write after process for the updated value of the parity record.

This is a continuation application of U.S. Ser. No. 09/956,792, filedSep. 21, 2001, which is a continuation application of U.S. Ser. No.09/642,815, filed Aug. 22, 2000, now U.S. Pat. No. 6,327,673, which is acontinuation application of U.S. Ser. No. 09/259,408, filed Feb. 22,1999, now U.S. Pat. No. 6,145,091, which is a continuation applicationof U.S. Ser. No. 08/877,627, filed Jun. 18, 1997, now U.S. Pat. No.5,917,999, which is a continuation application of U.S. Ser. No.07/827,982, filed Jan. 29, 1992, now U.S. Pat. No. 5,682,396.

BACKGROUND OF THE INVENTION

The present invention relates to a method for controlling a control unitwith cache memory for a disk array and a storage unit subsystem which iscomposed of an array of disks ad a control unit with cache memory.

The prior art most relevant to the present invention is David A.Patterson et al, “A Case for Redundant Arrays of Inexpensive Disks(RAID)”, ACM SIGMOD Conference Proceeding, Chicago, Ill., Jun. 103,1988, pp. 109-116.

The Patterson et al's article discloses a technique concerning thedistribution of data on a disk array.

A disk array is physically composed of a plurality of small scale diskunits but it is a disk system which operates as one disk unit for aprocessor. Namely, the disk array is a mechanism for attainingperformance improvement and high reliability.

The Patterson et al's article proposes some data distribution method.According to a typical one of the disclosed data distribution methods, arecord as a read/write unit for a processor is distributed on a diskunit as it is. In the invention, the distribution will hereinafter bereferred to as data distribution will hereinafter be referred to as datadistribution by record. The Patterson et al's article also proposes adata distribution method in which one record is divided into a pluralityof data and the individual data are distributed on a plurality of diskunits, respectively. This distribution is referred as RAIDS4 or RAID5. Afeature of the data distribution by record lies in that a read/writeprocess can be independently performed for each of disk units whichconstitute the disk array. In the case where one record is divisionallydistributed on a plurality of disk units, a read/write process for onerecord monopolizes the plurality of disk units. Accordingly, in the caseof the data distribution by record, the concurrency of read/writeprocesses capable of being performed in the disk array is improved,thereby attaining the improvement in the performance of the whole of thedisk array.

On the other hand, the high reliability of the disk array is realized insuch a manner that redundant data called parity data are stored in diskunits. Hereinafter, a record storing data read/written by a processorwill be referred as a data record, and a record storing redundant datawill be referred as a parity record. In the data distribution by record,a parity record is generated from a group of data records each of whichis stored in each disk unit in a disk array. An assembly of a parityrecord and data records from which the parity record is generated, istermed a parity group. Usually, records in the same parity group arestored in separate disk units. One parity group may include one or moreparity records.

In the case where an error occurs in any one the data records from whicha parity record was generated, the content of the faulty data record isrecovered from the contents of the parity record and the other datarecords. Accordingly, even if an error occurs in any disk unit in theassembly of disk units in which a parity group is stored, data can berecovered. Usually, if the number of parity records in one parity groupis n, data in the parity group can be recovered even if errors occur inas many as n disk units.

In the case of the data distribution mentioned above, the updating of aparity record becomes necessary each time the content of a data recordis changed by a write process. Therefore, the performance of a writeprocess is degraded as compared with the conventional disk device. Inaddition, the determination of an updated value of the parity recordneeds a preprocess for obtaining one of the following sets (1) and (2)of values:

(1) old values (hereinafter update before values) of a data record madethe object of the write process and the parity record; and

(2) the values of other data records in a parity group to which a datarecord made the object of the write process belongs.

The values mentioned by (1) can be acquired with small overhead.Therefore, in the case where the write process occurs, a method ofacquiring the values mentioned by (1) is usually employed. In order toread the values mentioned by (1), disk unit access must be made twiceeven in the case where only one parity record is included in the paritygroup. Further, in order to write the updated value of the data recordmade the object of the write process and the updated value of the parityrecord, disk unit access must be made twice. Accordingly, the diskaccess that is required is four times in total. In the case of theconventional disk, on the other hand, it is only required that theupdated value of a record made the object of a write process should bewritten into a disk unit. Namely, the number of disk accesses requiredfor a write request in the disk array using the data distribution byrecord is four times of that in the conventional disk.

There is not known a technique concerning the speedup of a write processin the disk array which uses the data distribution by record. But, thefollowing techniques are known as techniques for the speedup of a writeprocess in a general disk unit.

JP-A-53-157053 discloses a technique for improving the speed of a writerequest in a control unit having a disk cache by using a write afterprocess. The control unit completes a write process at a stage of timewhen write data received from a processor is written into the cache.Thereafter, the data stored in the cache is written into a disk unitthrough a write after process by the control unit.

JP-A-59-135563 discloses a technique concerning a control unit whichmakes the speedup of a write process while ensuring high reliability.The control unit has a nonvolatile memory as well as a cache memory sothat write data received from a processor is stored in the cache memoryand the nonvolatile memory. The write data is written into a disk unitthrough a write after process by the control unit. Thereby, the highreliability of the write after process is attained.

JP-A-60-114947 discloses a technique concerning a control unit whichcontrols disk units for double-write and has a cache memory or diskcache. When receiving a write request from a processor, the control unitwrites write data received from the processor into one disk unit and thecache memory. In asynchronism with a read/write request from theprocessor, the control unit writes the write data stored in the cachememory into the other disk unit later on.

JP-A-2-37418 discloses a technique for attaining the speedup by applyinga disk cash to disk units for double-write. A control unit has anonvolatile memory as well as a cache memory so that write data receivedfrom a processor is stored in the cache memory and the nonvolatilememory. The control unit writes the write data into the two disk unitsthrough a write after process.

JP-A-3-37746 discloses a technique concerning a control unit which has adisk cache and performs a write after process, or more particularly, atechnique concerning a management data structure of write after data inthe disk cache which is intended for efficient execution of the writeafter process in such a control unit.

Each of the above prior arts disclosing a write after process using adisk cache (hereinafter simply abbreviated to cache) for an usual orconventional disk unit shows a simple technique by which write datareceived by the cache from a processor is written into the disk unit.However, in the case of a disk array using the data distribution byrecord, it is necessary to generate the updated value of a parityrecord. Therefore, the overhead for a write process becomes large ascompared with the conventional disk unit. Accordingly, how to generatethe updated value of the parity record furnishes a key for the speedupof the write process in the disk array using the data distribution byrecord. On the contrary, in the conventional disk unit, suchconsideration is unnecessary since the updated value of a parity recordis not required.

SUMMARY OF THE INVENTION

An object of the present invention is to improve the efficiency ofgeneration of an updated value of a parity record, thereby attaining theimprovement in performance of a write process for a disk array whichuses the data distribution by record. Basically, a control unit of thepresent invention too performs a write after process using a cache, likethe case of a control unit for the conventional disk unit. However, thecontrol unit of the present invention efficiently makes the generationof an updated value of a parity record which is not disclosed by theprior art.

To achieve the above object, a control unit according to an embodimentof the present invention is provided with two kinds of mechanisms bywhich that information which is necessary for generation of an updatedvalue of a parity record and which does not exist in a disk cache, isloaded into the disk cache.

The first mechanism loads that information which are necessary forgeneration of the updated value of the parity record and which is to beprepared in synchronism with a write request received from a processor,form a disk unit into the disk cache in synchronism with the writerequest. The first mechanism makes it possible to reduce or remove aprocess in which information having already been stored in the diskcache is again loaded into the disk cache from disk units.

The second mechanism loads, that information which is necessary forgeneration of the updated value of the parity record and which does notneed to be prepared in synchronism with the write request received fromthe processor, from a disk unit into the disk cache in asynchronism withthe write request. The second mechanism makes it possible to generatethe updated value of the parity record with no intervention of theprocessor.

Further, the control unit may be provided with a mechanism whichasynchronously performs a process for generation of the updated value ofthe parity record. Thereby, it is possible to perform the process forgeneration of the updated value of the parity record with nointervention of the processor.

Also, the control unit may be provided with a mechanism whichasynchronously performs a process for write of the updated value of theparity record from the disk cache into a disk unit. Thereby, it ispossible to perform the process for write of the updated value of theparity record from the disk cache into the disk unit with nointervention of the processor.

As mentioned above, the control unit of the embodiment performs aprocess for generation of an updated value of a parity record attendantupon a write request from a processor with no intervention of aprocessor. Therefore, the speed of a write process for a disk arrayusing the data distribution by record can be increased. Also, thecontrol unit of the embodiment loads only information necessary foracquisition of the updated value of the parity record into a disk cache.Therefore, the process for generation of the updated value of the parityrecord can be performed with high efficiency.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram showing the outline of the present invention;

FIG. 2 is a block diagram showing the outline of the operation of acontrol unit in a first embodiment of the present invention in the casewhere when the control unit receives a write request from a processor,data necessary for generation of an updated value of a parity record isnot stored in a cache;

FIG. 3 is a block diagram showing the outline of the operation of thecontrol unit in the first embodiment of the present invention in thecase where while generating the updated value of the parity record, thecontrol unit writes the updated value into a disk unit;

FIG. 4 is a block diagram showing the outline of the operation of acontrol unit in a second embodiment of the present invention in the casewhere when the control unit receives a write request from a processor,data necessary for generation of an updated value of a parity record isstored in a cache;

FIG. 5 is a block diagram showing the outline of the operation of thecontrol unit in the second embodiment of the present invention in thecase where the control unit receives the write request from theprocessor, data necessary for generation of the updated value of theparity record is not stored in the cache;

FIG. 6 is a block diagram showing the outline of the operation of thecontrol unit in the second embodiment of the present invention in thecase where while generating the updated value of the parity record, thecontrol unit writes the updated value into a disk unit;

FIG. 7 is a block diagram showing the outline of the operation of acontrol unit in a third embodiment of the present invention in the casewhere when the control unit receives a write request from a processor,data necessary for generation of an updated value of a parity record isstored in a cache;

FIG. 8 is a block diagram showing the outline of the operation of thecontrol unit in the third embodiment of the present invention in thecase where the control unit receives the write request from theprocessor, the data necessary for generation of the updated value of theparity record is not stored in the cache;

FIG. 9 is a block diagram showing the outline of the operation of thecontrol unit in the third embodiment of the present invention in thecase where while generating the updated value of the parity record, thecontrol unit writes the updated value into a disk unit;

FIG. 10 is a block diagram showing the outline of the operation of acontrol unit in a fourth embodiment of the present invention in the casewhere when the control unit receives a write request from a processor,data necessary for generation of an updated value of a parity record isstore din a cache;

FIG. 11 is a block diagram showing the outline of the operation of thecontrol unit in the fourth embodiment of the present invention in thecase where the control unit receives the write request from theprocessor, the data necessary for generation of the updated value of theparity record is not stored in the cache;

FIG. 12 is a block diagram showing the outline of the operation of thecontrol unit in the fourth embodiment of the present invention in thecase where while generating the updated value of the parity record, thecontrol unit writes the updated value into a disk unit;

FIG. 13 is a block diagram showing a first example of the constructionof a computer system which embodies the present invention;

FIG. 14 is a block diagram showing a second example of the constructionof a computer system which embodies the present invention;

FIG. 15 is a diagram for explaining the kinds of records which can bestored in a disk unit;

FIG. 16 is a diagram for explaining records which constitute a paritygroup;

FIG. 17 is a block diagram showing a third example of the constructionof a computer system which embodies the present invention;

FIG. 18 is a diagram for explaining the construction of a cache;

FIG. 19 is a diagram for explaining the construction of a segment;

FIG. 20 is a diagram for explaining the construction of a directory;

FIG. 21 is a diagram for explaining the construction of a track table;

FIG. 22 is a diagram for explaining the construction of parity group(PG) management information;

FIG. 23 is a diagram for explaining the structure of an empty segmentqueue;

FIG. 24 is a diagram for explaining the construction of an empty PGmanagement information queue;

FIG. 25 is a diagram for explaining the construction of a nonvolatilememory;

FIG. 26 shows a flow chart of a process performed by a hit/miss judgepart a;

FIG. 27 shows a flow chart of a process performed by the hit/miss judgepart a when the release from a wait condition is made;

FIG. 28 shows a flow chart of a process performed by a synchronous dataload part a;

FIG. 29 shows a flow chart of a process performed by the synchronousdata load part a when a disk unit positioning process is completed;

FIG. 30 shows a flow chart of a process performed by a synchronous datawrite part a;

FIG. 31 shows a flow chart of a process performed by the synchronousdata write part a when a disk unit positioning process is completed;

FIG. 32 shows a flow chart of a process performed by a synchronous datawrite part b;

FIG. 33 shows a flow chart of a process performed by the synchronousdata write part b when a disk unit positioning process is completed;

FIG. 34 shows a flow chart of a process performed by an asynchronousrecord load part a;

FIG. 35 shows a flow chart of a process performed by the asynchronousrecord load part a when a disk unit positioning process is completed;

FIG. 36 shows a flow chart of a process performed by an asynchronousrecord write part a;

FIG. 37 shows a flow chart of a process performed by the asynchronousrecord write part a when a disk unit positioning process is completed;

FIG. 38 shows a flow chart of a process performed by a hit/miss judgepart b;

FIG. 39 shows a flow chart of a process performed by a synchronous datawrite part c;

FIG. 40 shows a flow chart of a process performed by an asynchronousrecord load part b;

FIG. 41 shows a flow chart of a process performed by an asynchronousrecord write part b;

FIG. 42 shows a flow chart of a process performed by the asynchronousrecord write part b when a disk unit positioning process is completed;

FIG. 43 shows a flow chart of a process performed by a hit/miss judgepart c;

FIG. 44 shows a flow chart of a process performed by a synchronous datawrite part d;

FIG. 45 shows a flow chart of a process performed by a synchronous datawrite part e;

FIG. 46 shows a flow chart of a process performed by a hit/miss judgepart d;

FIG. 47 shows a flow chart of a process performed by a synchronous datawrite part f;

FIG. 48 shows a flow chart of a process performed by a hit/miss judgepart e;

FIG. 49 shows a flow chart of a process performed by a synchronous datawrite part g;

FIG. 50 shows a flow chart of a process performed by a synchronous datawrite part h;

FIG. 51 shows a flow chart of a process performed by an asynchronousrecord load part c;

FIG. 52 shows a flow chart of a process performed by a hit/miss judgepart f;

FIG. 53 shows a flow chart of a process performed by a synchronous datawrite part i;

FIG. 54 shows a flow chart of a process performed by an asynchronousrecord load part d;

FIG. 55 shows a flow chart of a process performed by an asynchronousrecord write part c;

FIG. 56 shows a flow chart of a process performed by a hit/miss judgepart g;

FIG. 57 shows a flow chart of a process performed by a synchronous datawrite part j;

FIG. 58 shows a flow chart of a process performed by a synchronous datawrite part k;

FIG. 59 shows a flow chart of a process performed by a hit/miss judgepart h;

FIG. 60 shows a flow chart of a process performed by a synchronous datawrite part m;

FIG. 61 shows a flow chart of a process concerning the operation of acontrol unit in a fifth embodiment of the present invention;

FIG. 62 is a block diagram showing the outline of the operation of thecontrol unit in the first embodiment of the present invention in thecase where when the control unit receives the write request from theprocessor, the data necessary for generation of the updated value of theparity record is stored in the cache;

FIG. 63 is a block diagram showing the state of a cache when a writerequest for a data record is accepted before a load process needed inconnection with the preceding write request is completed for a parityrecord in a parity group to which that data record belongs;

FIG. 64 shows a block diagram showing the state of a cache after a writerequest for a data record has been accepted before a loads processneeded in connection with the preceding write request is completed for aparity record in a parity group to which that data record belongs;

FIG. 65 is a block diagram showing the outline of a parity grouphit/miss judge process a;

FIG. 66 is a block diagram showing the outline of a parity grouphit/miss judge process b;

FIG. 67 is a block diagram showing the outline of a parity grouphit/miss judge process c;

FIG. 68 is a block diagram showing the outline of an asynchronousprocess a;

FIG. 69 is a block diagram showing the outline of an asynchronousprocess b;

FIG. 70 is a block diagram showing the outline of an asynchronousprocess c;

FIG. 71 is a block diagram showing the outline of an asynchronousprocess d;

FIG. 72 is a block diagram showing the outline of a parity generationtiming a;

FIG. 73 is a block diagram showing the outline of a parity generationtiming b;

FIG. 74 is a block diagram showing the outline of a parity generationtiming c;

FIG. 75 is a block diagram showing the outline of the operation of thecontrol unit in the first embodiment of the present invention in thecase where the generation of the updated value of the parity record ismade in asynchronism with a data transfer process of the control unit;

FIG. 76 is a block diagram showing the outline of the operation of thecontrol unit in the second embodiment of the present invention in thecase where the generation of the updated value of the parity record ismade in asynchronism with a data transfer process of the control unit;

FIG. 77 is a block diagram showing the outline of the operation of thecontrol unit in the third embodiment of the present invention in thecase where the generation of the updated value of the parity record ismade in asynchronism with a data transfer process of the control unit;

FIG. 78 is a block diagram showing the outline of the operation of thecontrol unit in the fourth embodiment of the present invention in thecase where the generation of the updated value of the parity record ismade in asynchronism with a data transfer process of the control unit;

FIG. 79 shows a flow chart of a process performed by a hit/miss judgepart j;

FIG. 80 shows a flow chart of a process performed by a hit/miss judgepart k;

FIG. 81 shows a flow chart of a process performed by a hit/miss judgepart l;

FIG. 82 shows a flow chart of a process performed by a hit/miss judgepart m;

FIG. 83 shows a flow chart of a process performed by an asynchronousrecord load part f;

FIG. 84 shows a flow chart of a process performed by a parity generationpart a;

FIG. 85 shows a flow chart of a process performed by a parity generationpart b;

FIG. 86 is a block diagram showing the outline of a parity generationtiming d; and

FIG. 87 is a table showing a relationship between mechanisms which solveproblems included in the present invention and the first to fifthembodiments which are of the present invention.

DESCRIPTION OF THE PREFERRED EMBODIMENTS

Embodiments of the present invention will now be explained. In thepresent invention, a write action using a disk cache is performed for adisk array which uses the data distribution by record. In the following,therefore, explanation will be made of only the write action.

1. COMMON CONTENTS

First of all, explanation will be made of contents which are common tothe embodiments.

1) Computer System

FIG. 13 shows a first example of the construction of a computer systemwhich embodies the present invention. The computer system is composed ofa processor 1300, a control unit 1305 and more than one disk units 1304.The processor 1300 includes a CPU 1301, a main storage 1302 and channels1303. The control unit 1305 includes a cache memory 1308 and a director1309. That data among data stored in the disk units 1304 which has ahigher access rate, is loaded into the cache memory (hereinafter simplyabbreviated to cache) 1308. Management information of the cache 1308 isstored in the directory 1309. The control unit 1305 makes the transferof data between the processor 1300 and the disk units 1304 or betweenthe cache 1308 and the disk units 1304 in accordance with a read/writerequest from the processor 1300. The control unit further performs aread/write action between the disk units 1304 and the cache 1308 inasynchronism with the read/write request from the processor 1300.However, it should be noted that the present invention can be applied toa construction, as shown in FIG. 17, in which a control unit 1305includes two or more directors 1307 and each director 1307 accepts aread/write request from a processor 1300 to perform a read/write action.

FIG. 14 shows a second example of the construction of a computer systemwhich embodies the present invention. The construction of FIG. 14 isdifferent from the construction of FIG. 13 in that a control unit 1305further includes a nonvolatile memory 1400 and nonvolatile memorymanagement information 1401. The nonvolatile memory 1400 is constructedwith a nonvolatile medium. Like a cache 1308, the nonvolatile memory1400 is loaded with that data among data stored in disk units 1304 whichhas a higher access rate. The nonvolatile memory management information1401 too is constructed with a nonvolatile medium and managementinformation of the nonvolatile memory 1400 is stored into thenonvolatile memory management information 1401.

In the computer systems shown in FIGS. 13 and 14, the control unit 1305can select either one of two actions based on first and second methods,which will be mentioned hereinbelow, as an action for a write requestaccepted from the processor 1300.

The first method is a write through action or process 1301 shown in FIG.13. In the write through action 1310, the control unit 1305 writes,write data 1312 received from the processor 1300, directly into a diskunit 1304 and further writes the same write data 1312 into the cache1308. The write through action 1310 is not shown in FIG. 14. However, inthe construction shown in FIG. 14 too, the control unit 1305 can performthe write through action 1310.

The second method is a fast write action or process 1311 shown in FIGS.13 and 14. In the fast write action 1311, the control unit 1305completes a write process at a state of time when write data 1312received from the processor 1300 is written into the cache 1308. In thiscase, it is possible to complete the write request without making accessto a disk unit 1304. Therefore, a high-speed process can be realized.The write data 1312 written in the cache 1308 is written into a diskunit 1304 in asynchronism with the write request from the processor 1300during a time when the control unit 1305 is idle. Such a write processis termed a write after process 1313.

In the computer system shown in FIG. 14, the control unit 1305 canfurther perform a reliable fast write action or process 1402. Thereliable fast write action 1402 is different from the fast write action1311 in that the write data 1312 is also written into the nonvolatilememory 1400. Thereby, the write data 1312 is ensured even if the cache1308 breaks down before the control unit 1305 performs the write afterprocess 1313.

2) Store Format of Data

Next, the store format of data in a disk array using the datadistribution by record, to which the present invention is directed, willbe explained by use of FIGS. 15 and 16.

As shown in FIG. 15, the unit of data read from or written in a diskunit 1304 is called a record 1502. Two kinds of records 1502, that is, adata record 1500 and a parity record 1501 can be stored in disk units1304 of the present invention. The data record 1500 is a record in whichdata read or written by the processor 1300 is stored. On the other hand,the parity record 1501 is a record 1502 which is used for a process forrecovery from an error which may occur in any disk unit 1304.

FIG. 16 shows the construction of a parity group 1600 in the disk arrayusing the data distribution by record. Data records 1500 are stored in mcorresponding disk units 1304 inclusive of disk units a 1601 to d 1604,respectively. From the m data records 1500 are generated n parityrecords 1501 which are in turn stored into n corresponding disk units e1605 to f 1606, respectively. In FIG. 16, the parity group 1600 isconstructed by the m data records 1500 and the n parity records 1501.Generally, as for a parity group 1600 including n parity records 1501,the contents of all records 1502 in the parity group 1600 can berecovered even if n disk units 1304 among (m+n) disk units having therecords in the parity group 1600 stored therein break down. The presentinvention is also applicable to the case where the assembly of diskunits 1304 stored records forming a parity group 1600 or the number(m+n) of records 1502 forming a parity group 1600 as shown in FIG. 16 isdifferent in each parity group 1600.

Embodiments as mentioned later on will be explained by virtue of theparity group 1600 shown in FIG. 16.

FIG. 18 shows the construction of the cache 1308. The cache 1308includes a plurality of segments 1800. One record 1502 on a disk unit1304 is stored in each segment 1800.

FIG. 19 shows the construction of each segment 1800. The segment 1800 iscomposed of a pointer 1900 and a data area 1901. The pointer is usedwhen empty segments 1800 are to be linked with each other. The data orparity record 1502 is stored in the data area 1901.

FIG. 20 shows the construction of the directory 1309. A record table2000 is information indicative of whether or not records 1502 are storedin the cache 1308. P (parity group) management information 2001 isinformation for managing records 1502 in a parity group 1600 stored inthe cache 1308. An empty segment queue management pointer 2002 and anempty PG management information pointer 2003 are pointers for managingsegments 1800 and PG management information 2001 which are in emptyconditions, respectively. As disk unit occupy information 2004 isstored, for each disk unit 1304, information indicating that each diskunit 1304 is operating. As disk unit wait information 2005 is stored,for each disk unit 1304, information indicating that a read/writerequest from the processor 1300 is in a wait condition.

FIG. 21 shows the construction of the record table 200. The record table200 has entries which correspond to records 1502 included in the diskunits 1304, respectively. The entries are arranged in the order of thedisk unit numbers of the disk units 1304 and in the order of the recordnumbers of records 1502 in the same disk unit 1304. In the case wherenone of records 1502 in the parity groups 1600 which the record 1502belongs to are stored in the cache 1308, the content of the entry of therecord 1502 takes a null value. On the other hand, in the case where anyone of the records 1502 in the parity groups 1600 which the record 1502belongs to is stored in the cache 1308, the entry of the record 1502indicates the PG management information 2001.

FIG. 22 shows the construction of the PG management information 2001. Anempty pointer 2206 is used for linking empty management information 2202with each other. An update before segment pointer 2200 indicates asegment 1800 in which the update before content of a record 1502corresponding to the entry is stored. An update after segment pointer2201 indicates a segment in which the update after value of a record1502 corresponding to the entry is stored. In the case where both theupdate before segment pointer 2200 and the update after segment pointer2201 take null values, it is meant that the corresponding record 1502 isnot stored in the cache 1308. A write after bit 2202 is informationindicating that a write after process 1313 for a record 1502corresponding to the entry should be performed. A load request bit 2203is information indicating that a record 1502 corresponding to the entryshould be loaded into the cache 1308. Since the update before segmentpointer 2200, the update after segment pointer 2201, the write after bit2202 and the load request bit 2203 are provided corresponding to eachrecord 1502, the PG management information 2001 includes each of thosedata which is (m+n) in number equal to the number of records 1502included in the corresponding parity group 1600. Lock information 2204indicates that the records 1502 in the parity group 1600 correspondingto the PG management information 2001 under consideration are beingoperated. In a write action for the disk array using the datadistribution by record, not only a data record 1501 but also all parityrecords 1501 are updated. Therefore, it is required that a write actionfor the same parity group 1600 is sequentially performed (or serialized)in accordance with the lock information 2204. Lock wait information 2205is information indicating that a read/write request from the processor1300 is in a wait condition. The lock wait information 2205 is providedfor ensuring that the write action will be performed sequentially. Aparity generation bit 2206 is information indicating that records 1502necessary for generation of updated values of parity records 1501belonging to the parity group 1600 corresponding to the PG managementinformation 2001 under consideration are stored in the cache 1308.

FIG. 23 shows the construction of an empty segment queue 2300. A leadingone 1800 of segments 1800 the data areas 1901 of which are in emptyconditions, is pointed by the empty segment queue management pointer2002. A subsequent segment 1800 is pointed by a pointer 1900 included inthe preceding segment 1800.

FIG. 24 shows the construction of an empty PG management informationqueue 2400. Leading one 2001 of PG management information 2001 which arein empty conditions, is pointed by the empty PG management informationpointer 2003. Subsequent PG management information 2001 is pointed by anempty pointer 2206 included in the preceding PG management information2001.

FIG. 25 shows the construction of the nonvolatile memory 1400. Thenonvolatile memory 1400 includes a plurality of nonvolatile segments2500. The construction of each nonvolatile segment 2500 is similar tothat of the segment 1800 shown in FIG. 19. Also, the construction of thenonvolatile memory management information 1401 is similar to that of thedirectory 1309 shown in FIG. 20.

3) Outline and Problems

The outline of the present invention will be explained by use of FIG. 1.

When a control unit 1305 receives a write request from a processor 1300,a hit/miss judge part i 1700 refers to a directory 1309 (in conjunctionwith a data line 1705) to check whether or not information necessary forgeneration of an updated value of a parity record 1501 (see FIG. 15)exists in a cache 1308.

At this time, in the case where the information necessary for generationof the updated value of the parity record 1501 is to be prepared insynchronism with the write request, the control unit 1305 first loadsthe necessary information into the cache 1308 by use of a synchronousrecord load part b 1702 (in conjunction with a data line 1707).

Next, the control unit 1305 receives write data 1312 for a data record1500 from the processor 1300 by use of a synchronous data write part m1701. At this time, either a write through process 1310 (FIG. 13), afast write process 1311 (FIG. 13 or 14) or a reliable fast write process1402 (FIG. 14) can be applied for the write request. If the informationnecessary for generation of the updated value of the parity record 1501(FIG. 15) is complete in the cache 1308, it is possible to generate theupdated value of the parity record 1501 (in conjunction with a data line1706).

The updated value of the parity record 1501 may also be generated usinga parity generation part c 1710 (in conjunction with a data line 1711)after the write request from the processor 1300 has been completed.

In the case where the information necessary for generation of theupdated value of the parity record 1501 may be prepared in asynchronismwith the write request from the processor 1300, the control unit 1305loads the necessary information into the cache 1308 by use of anasynchronous record load part e 1703. With this load process, the parityrecord 1501 can be generated (in conjunction with a data line 1708) at astage of time when the information necessary for generation of theparity record 1501 becomes complete in the cache 1308. In this case too,the updated value of the parity record 1501 may be generated using theparity generation part c 1710 (in conjunction with the data line 1711)after a process for loading the information necessary for generation ofthe updated value of the parity record 1501 has been completed.

Using an asynchronous record write part d 1704, the control unit 1305performs a write after process 1313 (FIG. 13 or 14) for the updatedvalue of the parity record 1501 or the data record 1500 written in thecache 1308 through the fast write process 1311 (FIG. 13 or 14) or thereliable fast write process 1402 (FIG. 14). In this case too, inparallel with generation of the updated value of the parity record 1501from the information necessary for generation of the updated value ofthe parity record 1501, the control unit 1305 can write the updatedvalue into a disk unit 1304 (in conjunction with a data line 1709).

Though the above is the outline of the present invention, the detailedoperation of the control unit 1305 differs depending on specificstrategies for the following problems.

Problem 1 - - - This concerns a method of selecting informationnecessary for generation of an updated value of a parity record 1501(FIG. 15), that is, which information should be used to generate theupdated value of the parity record.

Problem 2 - - - This concerns the asynchronization of a processassociated with the generation of the updated value of the parity record1501. By performing the process associated with the generation of theupdated value fop the parity record 1501 in asynchronism with theprocessor, the process associated with the generation of the updatedvalue of the parity record is caused not to be included in a responsetime seen from the processor.

Problem 3 - - - This concerns the timing of generation of the updatedvalue of the parity record 1501, that is, which timing the updated valueof the parity record 1501 should be generated at.

4) Parity Group Hit/Miss Judge Process

First, in the present invention, three methods as mentioned hereinbelowby (a) to (c) are provided as means for solution of the problem 1, thatis, the method of selection of the information necessary for generationof the updated value of the parity record 1501.

(a) In a parity group hit/miss judge process a 6500, to generate anupdated value of a parity record 1501 is acquired from an update beforevalue of a data record 1500 designated as the object of write and anupdate before value of the parity record 1501 are necessary. For thatpurpose, the hit/miss condition 6502 (or the presence/absence in a cache1308) of the data record 1500 (1502) designated as the object of writefrom the processor 1300 and the hit/miss condition 6501 of the parityrecord 1501 (1502) are judged while referring to a directory 1309 (inconjunction with a data line 6503). As a result, a record 1502 amongthose records 1502 which is missing, is loaded into the cache 1308 (inconjunction with a data line 6504).

(b) In a parity group hit/miss judge process b 6600 shown in FIG. 66, togenerate an updated value of a parity record 1501, other data records1500 included in a parity group 1600 (FIG. 16) to which a data record1500 designated as the object of write belongs are necessary. For thatpurpose, the hit/miss conditions 6601 of the other data records 1500(1502) included in the parity group 1600 to which the data record 1500designated as the write object from the processor 1300 belongs, arejudged while referring to a directory 1309 (in conjunction with a dataline 6602). As a result, a record 1502 among those records 1502 which ismissing, is loaded into a cache 1308 (in conjunction with a data line6603).

(c) In a parity group hit/miss judge process c 6700 shown in FIG. 67,the hit/miss condition 6502 of an update before value of a data record1500 designated as the object of write, the hit/miss condition of anupdated before value of a parity record 1501 and the hit/miss conditions6601 of other data records 1500 included in a parity group 1600 to whichthe data record 1500 designated as the object of write from theprocessor 1300 belongs, are judged (in conjunction with a data line6701). As a result, one of the parity group hit/miss judge process a6500 and the parity group hit/miss judge process b 6600 shown in FIGS.65 and 66 which is advantageous from an aspect of performance, isselected and performed. For example, in the case where all other datarecords 1500 included in the parity group 1600 to which the data record1500 designated as the object of write belongs exist in a cache 1308 andthe parity record 1501 does not exist in the cache 1308, the selectionof the parity group hit/miss judge process b 6600 rather than the paritygroup hit/miss judge process a 6500 is advantageous in an aspect ofefficiency.

5) Asynchronous Process

Nest, in the present invention, four kinds of asynchronous processes asmentioned hereinbelow by (a) to (d) are provided as means for solutionof the problem 2, that is, means for asynchronization.

(a) In an asynchronous process a 6800 shown in FIG. 68, an update afterparity record 108 (or an update after value of a parity record) isgenerated by use of an update before data record 105 (or an updatebefore value of a data record) and an update before parity record 107(or an update before value 6803 of the parity record). Accordingly, thisprocess is used in combination with the parity group hit/miss judgeprocess a 6500. Further, the asynchronous process a 6800 is used (inconjunction with a data line 6804) in the case where a process forupdating an update after data record 106 (or an updated value of a datarecord 1500 designated as the object of write) on a disk unit 1304 is tobe performed in synchronism with a write request from a processor 1300.If the update before data record 105 does not exist in a cache 1308, aprocess for loading the update before data record 105 into the cache1308 must be performed (in conjunction with a data line 6804) insynchronism with the write request from the processor 1300. Therefore,two processes as mentioned hereinbelow are asynchronously performed (inconjunction with a data lines 6805):

1 a load process in the case where the update before parity record 107does not exist in the cache 1308; and

2 a process for write of the update after parity record 108 into a diskunit 1304.

(b) In an asynchronous process b 6900 shown in FIG. 69, an update afterparity record 108 is generated by use of an update before data record105 and an update before parity record 107. Accordingly, this processtoo is used in combination with the parity group hit/miss judge processa 6500. Further, the asynchronous process b 6900 too is used (inconjunction with a data line 6904) in the case where a process forupdating an update after data record 106 on a disk unit 1304 is to beperformed in synchronism with a write request 6904 from a processor1300. Therefore, four processes as mentioned hereinbelow areasynchronously performed (in conjunction with a data lines 6905):

1 a load process in the case where the update before data record 105does not exist in a cache 1308;

2 a process for write of the update after data record 106 into a diskunit 1304;

3 a load process in the case where the update before parity record 107does not exist in the cache 1308; and

4 a process for write of the update after parity record 108 into a diskunit 1304.

(c) In an asynchronous process c 7000 shown in FIG. 70, an update afterparity record 108 is generated by use of in-group other data records 702(other data records 1500 included in a parity group 1600 to which a datarecord 1500 designated as the object of write belongs). Accordingly,this process is used in combination with the parity group hit/miss judgeprocess b 6600. Further, the asynchronous process c 7000 is used (inconjunction with a data line 7004) in the case where a process forupdating an update after data record 106 on a disk unit 1304 is to beperformed in synchronism with a write request from a processor 1300. Thein-group other data records 702 may be acquired even after the updateafter data record 106 has been written into the disk unit 1304.Therefore, two processes as mentioned hereinbelow are asynchronouslyperformed (in conjunction with data lines 7005):

1 a load process in the case where the in-group other data record 702which does not exist in a cache 1308; and

2 a process for write of the update after parity record 108 into a diskunit 1304.

(d) An asynchronous process d 7100 shown in FIG. 71 is used in the casewhere an update after parity record 108 is generated by use of in-groupother data records 702. Accordingly, this process is used in combinationwith the parity group hit/miss judge process b 6600. Further, theasynchronous process d 7100 is used (in conjunction with a data line7104) in the case where a process for updating an update after datarecord 106 on a disk unit 1304 is to be performed in synchronism with awrite request from a processor 1300. Therefore, three processes asmentioned hereinbelow are asynchronously performed (in conjunction withdata lines 7105);

1 a load process in the case where the in-group other data record 702which does not exist in the cache 1308;

2 a process for write of the update after data record 106 into the diskunit 1304; and

3 a process for write of the update after parity record 108 into a diskunit 1304.

6) Timing Of Generation Of Update After Parity Record 108

Next, as means for solution of the problem 3 in the present invention,that is, the timing of generation of the update after parity record 108,explanation will be made of four kinds of timings a to d as mentionedhereinbelow.

(a) A parity generation timing a shown in FIG. 72 is a timing when anupdate after data record 106 designated from a processor 1300 istransferred from the processor 1300 to a control unit 1305 (inconjunction with a data line 7202 a). In this case, it is required thatinformation 7201 necessary for generation of an update after parityrecord 108 is completely stored in a cache 1308. A parity generationunit 7200 generates the update after parity record 108 (in conjunctionwith data lines 7202 b and 7202 c), as shown in FIG. 72.

(b) A parity generation timing b shown in FIG. 73 is a timing when thelast information among information 7201 necessary for generation of anupdate after parity record 108 is loaded into a cache 1308 (inconjunction with a data line 7300 a). In this case, it is required thatan update after data record 106 designated from the processor 1300 hasalready been stored in the cache 1308 (in conjunction with a data line7300 b).

(c) A parity generation timing c shown in FIG. 74 is a timing when inparallel with the generation of an updated value of a parity record by aparity generation unit 7200 on the basis of an update after data record106 and information 7201 necessary for generation of an update afterparity record 108 (in conjunction with date lines 7400 a and 7400 b),the generated updated value is written into a disk unit 1304 and a cache1308 (in conjunction with data lines 7400 c and 7400 d).

(d) A parity generation timing d shown in FIG. 86 is a timing when theparity generation is made by a parity generation unit 7200 (inconjunction with data lines 8600) in asynchronism with a process fordata transfer executed by a control unit 1305.

7) Relationship Between Embodiments

Five embodiments will be explained in connection with the presentinvention. Though the control unit 1305 used in the followingexplanation and shown in FIGS. 13, 14 and 17 is not shown expressly toinclude a unit for generating a parity record 1501, it is assumed thatthe control unit 1305 includes the unit for generating an updated valueof the parity record 1501. FIG. 87 shows a relationship between theembodiments of the present invention and the mechanisms or means forsolution of the problems in the present invention which are mentioned inconjunction with from FIG. 65 to FIG. 74.

2. First Embodiment

1) Outline

As shown in FIG. 87, a first embodiment is an embodiment in which theparity group hit/miss judge process a 6500 and the asynchronous processa 6800 are combined. All of the parity generation timings a to d arerelevant to the first embodiment.

The outline of the first embodiment will now be explained by use ofFIGS. 62 and 2.

FIG. 62 shows the operation of a control unit 1305 in the firstembodiment in the case where all update before parity records 107 in aparity group 1600 to which a data record 1500 made the object of writebelongs exist in a cache 1308. Namely, FIG. 62 shows the operation ofthe control unit 1305 in the first embodiment in the case where theparity generation timing a shown in FIG. 72 is used.

In this case, the timing of generation of an update after parity record108 is the timing of write of an update after data record 106 into adisk unit 1304, that is, the parity generation timing a. Concretely, thecontrol unit 1305 controls the above timing by use of a synchronous datawrite part a 101 (in conjunction with a data line 109 a). The updateafter parity record 108 itself is generated by a parity generation unita 104 (in conjunction with a data line 109 b). For the generation of theupdate after parity record 108, an update before data record 105 isneeded (in conjunction with a data line 109 c). Therefore, in the casewhere this record 105 is not stored in the cache 1308, the control unit1305 loads the record 105 into the cache 1308 by use of a synchronousdata load part a 102 (in conjunction with a data line 110) before theupdate after data record 106 is written into a disk unit 1304.

The update after parity record 108 is written into a disk unit 1304 byuse of an asynchronous record write part a 103 (in conjunction with adata line 111) in asynchronism with a read/write request from aprocessor 1300. In the present embodiment, the asynchronous record writepart a 103 writes a parity record 1501 into the disk unit 1304. In theother embodiments, however, there may be the case where the asynchronousrecord write part writes a data record.

FIG. 2 shows the operation of the control unit 1305 in the firstembodiment in the case where at least one of the update before parityrecords 107 in a parity group 1600 to which a data record 1500 made theobject of write belongs does not exist in a cache 1308. Namely, FIG. 2shows the operation of the control unit 1305 in the first embodiment inthe case where the parity generation timing b shown in FIG. 73 is used.

The control unit 1305 loads, the update before parity record 107 whichdoes not exist in the cache 1308, into the cache 1308 (in conjunctionwith a data line 203 a) by use of an asynchronous record load part a 201in asynchronism with a read/write request from a processor 1300. In thiscase, the timing of generation of an update after parity record 108 is atiming when the last information in the update before parity record 107which does not exist in the cache 1308 is loaded into the cache 1308 (inconjunction with the data line 203 a), that is, the parity generatingtiming b.

In the present embodiment, the asynchronous record load part a 201 loadsa parity record 1501 into the cache 1308. In the other embodiments,however, there may be the case where the asynchronous record load partloads a data record 1500.

As shown in FIG. 2, an update after data record 106 is written into adisk unit 1304 by a synchronous data write part b 200 of the controlunit 1305 (in conjunction with a data line 202). At this timing,however, the update after parity record 108 is not generated.

Since the operations of a synchronous data load part a 102 and anasynchronous record write part a 103 are similar to those in FIG. 62,explanation thereof will be omitted.

2) Details Of Processes

Next, explanation will be made of the details of the individual processparts shown in FIGS. 62 and 2.

a) Hit/Miss Judge Part a 100

FIGS. 26 and 27 show the flow charts of processes performed by thehit/miss judge part a 100. The hit/miss judge part a 100 has threeexecution start points. A first start point is a start point (a) shownin FIG. 26 or a start point at which the execution is started when awrite request from the processor 1300 is received. A second start pointis a start point (b) shown in FIG. 26 or a start point at which theexecution is started when a process by the synchronous data load part a102 is completed. A third start point is a start point (c) shown in FIG.27 or a start point at which the execution is started when the releasefrom a wait condition is made.

The process flow shown in FIG. 26 will now be explained.

Referring to disk unit occupy information 2004, the control unit 1305judges whether or not a disk unit 1304 which becomes the object of writeis empty (step 2600). If the disk unit is not empty, the flow jumps tostep 2613.

If the disk unit is empty, the control unit 1305 sets the correspondingdisk unit occupy information 2004 and searches for PG managementinformation 2001 of an update before data record 105 made the object ofwrite (step 2601). In the case where there is no corresponding PGmanagement information 2001, an empty PG management information queue2400 is searched to allocate new PG management information 2001.

In step 2602, reference to lock information 2204 is made to checkwhether or not the start of a write process is possible. If the start ispossible, the lock information is set in step 2603. If the start is notpossible, the flow jumps to step 2611. In step 2604, the control unit1305 is disconnected from the processor 1300 once.

In step 2605, the control unit 1305 checks whether or not an updatebefore data record 105 exists in the cache. In the case where the record105 does not exist, the synchronous data load part a 102 is called instep 2606, thereby completing the process once. In the case where therecord 105 exists, the check is made as to whether or not there is anyone among update before parity records 107 in a parity group 1600 whichdoes not exist in the cache 1308 (step 2607). If all the update beforeparity records 107 exist in the cache, the flow jumps to step 2610. Ifthere is any update before parity record 107 which does not exist in thecache, a load request bit 2203 corresponding to that record 107 isturned on (step 2608). Next, in step 2609, the control unit 1305activates the synchronous data write part b 200, thereby completing theprocess.

In step 2610, the control unit 1305 activates the synchronous data writepart a 101, thereby completing the process.

In step 2611, the control unit 1305 sets the corresponding lock waitinformation 2205 and resets the corresponding disk unit occupyinformation 2004. Next, in step 2612, the control unit 1305 is releasedfrom the state of connection with the processor 1300 once, therebybringing the accepted write request into a wait condition.

In step 2613, the control unit 1305 sets the corresponding disk unitwait information 2005. And, the flow goes to step 2612.

If the report of completion is received from the synchronous data loadpart a 102, the process is executed from the start point (b) shown inFIG. 26. Since the processings in and after step 2607 have already beendescribed, explanation thereof will be omitted.

The flow chart shown in FIG. 27 illustrates the flow of a processperformed when the control unit 1305 is released from a wait condition.In step 2700, the control unit 1305 makes connection with the processor1300. In step 2701, the control unit 1305 requires the processor 1300 toissue the write request again.

b) Synchronous Data Load Part a 102

FIGS. 28 and 29 show the flow charts of processes performed by thesynchronous data load part a 102.

The flow chart shown in FIG. 28 illustrates the flow of a processperformed by the synchronous data load part a 102 when it is called bythe hit/miss judge part a 100. In step 2800, the control unit 1305searches an empty segment queue 2300 and so on to ensure an emptysegment 1800 and sets a value indicative of the segment 1800 into anupdate before segment pointer 2200. In step 2801, the control unit 1305issues a positioning request to disk units 1304, thereby completing theprocess.

The flow chart shown in FIG. 29 illustrates the flow of a processperformed when a positioning process for disk units 1304 is completed.In step 2900, a data record 1500 on the disk unit 1304 is loaded as anupdate before data record 105 into the segment 1800 indicated by theupdate before segment pointer 2200. In step 2901, the control unit 1305turns the control to the start point b for the hit/miss judge part a 100shown in FIG. 26.

c) Synchronous Data Write Part a 101

FIGS. 30 and 31 show the flow charts of processes performed by thesynchronous data write part a 101.

The flow chart shown in FIG. 30 illustrates the flow of a processperformed when the synchronous data write part a 101 is called by thehit/miss judge part a 100. In step 3000, in the case where a segment1800 for storing an update after data record 106 is not ensured, thecontrol unit 1305 searches an empty segment queue 2300 and so on toensure the segment 1800 and sets a corresponding value into an updateafter segment pointer 2201. In step 3001, in the case where segments1800 for storing all update after parity records 108 are not ensured,the control unit 1305 searches the empty segment queue 2300 and so on toensure the segments 1800 and set corresponding values into update aftersegment pointers 2201 for parity records 1501. In step 3002, the controlunit 1305 issues a positioning request to disk units 1304, therebycompleting the process.

The flow chart shown in FIG. 31 illustrates the flow of a processperformed when a positioning process for disk units 1304 is completed.In step 3100, the control unit 1305 makes connection with the processor1300 again. In step 3101, the control unit 1305 writes data receivedfrom the processor 1300 into a disk unit 1304 and simultaneouslytherewith performs the following actions:

1 storing data received from the processor 1300 as an update after datarecord 106 into the segment 1800 indicated by the corresponding updateafter segment pointer 2201; and

2 generating all update after parity records 108 from an update beforedata record 105, the data received from the processor 1300 and allupdate before parity records 107 and storing the generated records intothe segments 1800 indicated by the corresponding update after segmentpointers 2201.

In step 3102, the control unit 1305 turns the update after data record106 corresponding to a data record 1501 made the object of write and allthe update after parity records 108 to an update before data record 105and update before parity records 107, respectively. Concretely, thesegments 1800 having been indicated by the corresponding update beforesegment pointers 2200 are released and the segments 1800 having beenindicated by the corresponding update after segment pointers 2201 areturned to ones indicated by the update before segment pointers 2200.And, null values are set into the corresponding update after segmentpointers 2201.

In step 3103, the control unit 1305 sets values into write after bits2202 corresponding to all parity records 1501.

Thereafter, in step 3104, lock information 2204 and disk unit occupyinformation 2004 are reset. In step 1305, the control unit 305 reportsthe completion to the processor 1300.

d) Synchronous Data Write Part b 200

FIGS. 32 and 33 show the flow charts of processes performed by thesynchronous data write part b 200.

The flow chart shown in FIG. 32 illustrates the flow of a processperformed by the synchronous data write part b 200 when it is called bythe hit/miss judge part a 100. In step 3200, in the case where a segment1800 for storing an update after data record 106 is not ensured, thecontrol unit 1305 searches an empty segment queue 2300 and so on toensure the segment 1800 and sets a corresponding value into an updateafter segment pointer 2201. In step 3201, the control unit 1305 issues apositioning request to a disk unit 1304, thereby completing the process.

The flow chart shown in FIG. 33 illustrates the flow of a processperformed when a positioning process for the disk unit 1304 iscompleted. In step 3300, the control unit 1305 makes connection with theprocessor 1300 again. In step 3301, the control unit 1305 writes datareceived from the processor 1300 into the disk unit 1304 andsimultaneously therewith stores the data received from the processor1300 into the segment 1800 as the update after data record 106.

When a write request for a certain data record 1500 from the processor1300 is accepted, there may be the case where an update after datarecord 106 and an update before data record 105 are both stored in thecache 1308.

FIG. 63 shows the case where when the preceding write request 6300 wasaccepted, there is a parity record a 6301 (having the data content C)among update before parity records 107 which has not been loaded in thecache 1308. In this case, write data accepted upon the preceding writerequest 6300 is stored as an update after data record a 6303 in thecache 1308. An update before data record a 6302 corresponds to writedata accepted upon the further preceding write request. In this case,since an updated value of a parity record 1501 reflecting the updateafter data record a 6303 (having the data content B) has not beengenerated, it is apparent that the data content C of the parity record a6301 on a disk unit 1304 is generated from the data content A of theupdate before data record a 6302.

FIG. 64 shows the case where when a load process for the update beforeparity record 107 is intended under the above circumstance, a writerequest for the same data record 1500, that is, the present writerequest 6400 is accepted before the load process is started. In thiscase, in order to generate an updated value of a parity record 1501reflecting data accepted through the present write request 6400, thereis needed the value of the update before data record a 6302 (having thedata content A) which is used when the value of the parity record a 6301(having the data content C) was generated. Accordingly, as shown in FIG.64, the update before data record a 6302 is held in the cache 1308 as itis and the write data accepted through the present write request 6400 isstored as an update after data record b 6401 (having the data content D)into the cache 1308.

From the foregoing, in step 3301 shown in FIG. 33, the update beforedata record 105 is held in the cache 1308 as it is and the write data(corresponding to the update after data record b 6401) accepted in thesegment 1800 indicated by the update after segment pointer 2201 isstored into the segment 1800 (corresponding to the update before datarecord a 6302) in which the update after data record 106 has beenstored. In step 3302, a load request bit 2203 corresponding to theupdate before parity record 107 which has not been loaded in the cache1308, is turned on. In step 3303, lock information 2204 and disk unitoccupy information 2004 are reset. Thereafter, in step 3304, the controlunit 1305 reports the completion of the process to the processor 1300.

e) Asynchronous Record Load Part a 201

FIGS. 34 and 35 show the flow charts of processes performed by theasynchronous record load part a 201.

The flow chart shown in FIG. 34 illustrates the flow of a processperformed using a time when the control unit 1305 is idle. In step 3400,the control unit 1305 refers to disk unit occupy information 2004 tosearch for disk units 1304 which are empty. In step 1301, the controlunit 1305 searches the searched-out empty disk units 1304 for a record1502 for which a load request bit 2203 is ON, searches for PG managementinformation 2001 in which lock information 2204 is OFF, and turns on thelock information 2204.

Next, in step 3402, the control unit 1305 performs a load process forthe searched-out record 1502. Namely, the control unit 1305 ensures asegment 1800 and sets a value into an update before segment pointer 2200corresponding to a parity record 1501 to be loaded. In step 3403, thecontrol unit 1305 issues a positioning request to the disk unit 1304.

The flow chart shown in FIG. 35 illustrates performed when a positioningprocess for a disk unit 1304 is completed. In step 3500, the controlunit 1305 checks whether or not load request bits 2203 in the PGmanagement information 2001 become all OFF by the load process for therecord 1502. If the bits 2203 are all OFF, the flow goes to step 3500.On the other hand, if any one of the bits 2203 is ON, the control unit1305 loads the record 1502 as an update before parity record 107 into asegment 1800 indicated by the corresponding update before segmentpointer 2200 (step 3501) and the flow thereafter goes to step 3507. Inthe case where the load request bits 2203 in the PG managementinformation 2001 becomes all OFF by this load process, update afterparity records 108 for all parity records 1501 are generated at thistiming. In step 3502, the control unit 1305 ensures segments 1800 forstoring the update after parity records 108 and sets pointers intorespective update after segment pointers 2201 corresponding to theparity records 1501.

In step 3503, the control unit 1305 searches data records 1500 in aparity group 1600 under consideration for all data records 1500 theupdated values of which are not reflected to the parity records 1501.Concretely, the search is made for a data record for which the contentsof an update before data record 105 and an update after data record 106are held in pair in the cache, that is, neither of an update beforesegment pointer 2200 and an update after segment pointer 2201 do nottake both null values, and the search is further made for all updatebefore parity records 107. Accordingly, whether the load process is aload process for data records 1500 or a load process for parity records1501, records 1502 loaded by the load process are used to generateparity records 1501.

In step 3504, the control 3505 performs the following operation whileloading the records 1501 into segments indicated by the correspondingupdate before segment pointers 2200. Namely, by use of the paritygeneration unit a 104, update after parity records 108 for all parityrecords 1501 are generated from the update before data records 105,update after data records 106 and all update before parity records 107which are searched out in step 3503. The generated update after parityrecords 108 are stored into segments 1800 indicated by the correspondingupdate after segment pointers 2201.

In step 3505, the control unit 1305 turns the update after data record106 corresponding to a data record 1501 made the object of write and allthe update after parity records 108 to an update before data record 105and update before parity records 107, respectively. A concreteprocessing is similar to that in step 3102 mentioned above.

In step 3506, the control unit 1305 sets values into write after bits2202 corresponding to all the parity records 1501.

In step 3507, load request bits 2203 corresponding to the parity records1501, lock information 2204 and disk unit occupy information 2004 arereset.

Finally, in step 3508, the control unit 1305 resets disk unit waitinformation 2005 and lock wait information 2204 to release a read/writerequest from the processor which is in a wait condition, therebycompleting the process.

f) Asynchronous Record Write Part a 103

FIGS. 36 and 37 show the flow charts of processes performed by theasynchronous record write part a 103.

The flow chart shown in FIG. 36 illustrates the flow of a processperformed using a time when the control unit 1305 is idle. In step 3600,the control unit 1305 refers to disk unit occupy information 2004 tosearch for disk units 1304 which are empty.

In step 3601, the control unit 1305 searches the searched-out empty diskunit 1304 for a record 1502 for which a write after bit 2202 is ON and aload request bit 2202 is OFF, searches for PG management information2001 in which lock information 2204 is OFF, and turns on the lockinformation 2204.

In step 3602, the control unit 1305 starts a write after process for thesearched-out record 1502 and issues a positioning request to a disk unit1304.

The flow chart shown in FIG. 37 illustrates the flow of a processperformed when a positioning process for a disk unit 1304 is completed.In step 3700, the control unit 1305 refers to an update before segmentpointer 2200 and an update after segment pointer 2201 which correspondsto the record 1502. In the case where the update after segment pointer2201 takes a null value, data in a segment 1800 indicated by the updatebefore segment pointer 2200 is written into the disk unit 1304. In thecase where, neither of the update before segment pointer 2200 and theupdate after segment pointer 2201 take null values, the recentlyaccepted data in a segment 1800 indicated by the update after segmentpointer 2201 is written into the disk unit 1304.

In step 3701, the control unit 1305 resets the corresponding write afterbit 2202, lock information 2204 and disk unit occupy information 2004.

Finally, in step 3702, the control unit 1305 resets disk waitinformation 2005 and lock wait information 2205 to release a read/writerequest from the processor which is in a wait condition, therebycompleting the process.

3) Other Method 1 For Realization Of First Embodiment 1

FIG. 3 is a block diagram for explaining another method 1 which realizesthe first embodiment. This method is different from the method shown inFIG. 1 or 2 in that the timing of generation of an update after parityrecord 108 is a timing when the update after parity record 108 itself iswritten into a disk unit 1304. Namely, FIG. 3 shows the operation of thecontrol unit 1305 in the first embodiment in the case where the paritygeneration timing c shown in FIG. 74 is used as a parity generationtiming.

An asynchronous record write part b 302 shown in FIG. 3 generates anupdate after parity record 108 from an update before data record 105, anupdate after data record 106 and an update before parity record 107 byuse of a parity generation unit a 104 and in parallel therewith writesthe generated update after parity record 108 into a disk unit 1304.Accordingly, a synchronous data write part c 301 and an asynchronousrecord load part b 303 have net a function of generating the updateafter parity record 108.

The detailed operation will be explained in the following.

a) Hit/Miss Judge Part b 300

FIG. 38 shows the flow chart of a process performed by a hit/miss judgepart b 300 shown in FIG. 3. The hit/miss judge part b 300 has threeexecution start points.

A first point is a start point a shown in FIG. 38 or a start point atwhich the execution is started when a write request from a processor1300 is received. A second start point is a start point b shown in FIG.38 or a start point at which the execution is started when a process bya synchronous data load part a 102 is completed. A third start point isa start point when the release from a wait condition is made. Since theflow of a process performed in conjunction with the third start point issimilar to that shown in FIG. 27 performed by the hit/miss judge part a100, explanation thereof will be omitted. The process flow of thehit/miss judge part b 300 shown in FIG. 38 is approximately the same asthat of the hit/miss judge part a 100 shown in FIG. 26. Therefore,processings in FIG. 38 corresponding to those shown in FIG. 26 aredesignated by the same step numbers used in FIG. 26 and only thedifference from FIG. 26 will be explained there. Namely, the hit/missjudge part b 300 activates or calls the synchronous data write part c301 in step 3800 after an update before data record 105 has been storedinto a cache 1308.

b) Synchronous Data Write Part c 301

FIG. 39 shows the flow chart of a process performed by the synchronousdata write part c 301 when a positioning process for a disk unit 1304 iscompleted. Since the flow of a processing performed by the synchronousdata write part c 301 when it is called by the hit/miss judge part b 300is the same as that shown in FIG. 32, explanation thereof will beomitted. The process flow of the synchronous data write part c 301 shownin FIG. 39 is approximately the same as that of the synchronous datawrite part c shown in FIG. 33. Therefore, processings in FIG. 39corresponding to those shown in FIG. 33 are designated by the same stepnumbers used in FIG. 33 and the difference from FIG. 33 will beexplained here. Namely, in step 3900, the control unit 1305 checkswhether or not all update before parity records 107 are stored in thecache 1308. If there is any record 107 which is not stored, the flowjumps to step 3303. If all the update before parity records 107 arestored, the control unit 1305 turns on write after bits corresponding tothose records 107.

c) Asynchronous Record Load Part b 303

FIG. 40 shows the flow chart of a process performed by the asynchronousrecord load part b 303 when a positioning process for a disk unit 1304is completed. Since the flow of a process performed using a time whenthe control unit 1305 is idle is the same as that shown in FIG. 34,explanation thereof will be omitted. The process flow of theasynchronous record load part b 303 shown in FIG. 40 corresponds to onein which the processing for generating the update after parity records108 is removed from the process flow of the asynchronous record loadpart a 201 shown in FIG. 35. Therefore, explanation is omitted here, inFIG. 40, processings corresponding to those shown in FIG. 35 aredesignated by the same step numbers as those used in FIG. 35.

d) Asynchronous Record Write Part b 302

FIGS. 41 and 42 show the flow charts of processes performed by theasynchronous record write part b 302.

The flow chart shown in FIG. 41 illustrates the flow of a processperformed using a time when the control unit 1305 is idle. Since theprocess flow shown in FIG. 41 is approximately the same as that shown inFIG. 36, processings in FIG. 41 corresponding to those shown in FIG. 36are designated by the same step numbers used in FIG. 36 and thedifference from FIG. 36 will be explained here. Namely, in step 4100,the judgement is made as to whether a record 1502 made the object ofwrite is a data record 1500 or a parity record 1501. In the case wherethe record 1502 made the object of write is a parity record 1501, thecontrol unit 1305 ensures a segment 1800 for storing an update afterparity record 108 and sets a pointer value into the correspondingsegment pointer 2201 (step 4101).

The flow chart shown in FIG. 42 illustrates the flow of a processperformed when a positioning process for a disk unit 1304 is completed.Since the process flow shown in FIG. 42 is similar to that shown in FIG.37, processings in FIG. 42 corresponding to those shown in FIG. 37 aredesignated by the same step numbers as those used in FIG. 37 and thedifference from FIG. 37 will be explained here. Namely, in step 4200,the control unit 1305 judges whether a record 1502 made the object ofwrite is a data record 1500 or a parity record 1501. In the case wherethe record 1502 is a data record 1500, the flow goes to step 3700. Inthe case where the record 1502 is a parity record 1501, the control unit1305 performs the following processing. First, in step 4201, the controlunit 1305 generates an update after parity record 108 from an updatebefore data record 105, an update after data record 106 and an updatebefore parity record 108 by use of the parity generation unit a 104 andin parallel therewith stores the generated update after parity record108 into a disk unit 1304 and a segment 1800 which is indicated by anupdate after segment pointer 2201 corresponding to this record 108. Instep 4202, the control unit 1305 checks whether or not write after bits2202 are all OFF. If there is any bit 2202 which is not OFF, the flowjumps to step 3701. If the bits 2202 are all OFF, the control unit 1305turns all update after data records 106 in the parity group 1600 whichbelong to the parity record 1500 made the object of write and all theupdate after parity records 108 to update before data records 105 andupdate before parity records 107, respectively (step 4203). Since thespecific content of this processing has already been mentioned inconjunction with step 3102, explanation thereof will be omitted here.

4) Other Method 2 For Realization Of First Embodiment 1

FIG. 75 is a block diagram for explaining still another method 2 whichrealizes the first embodiment. The method shown in FIG. 75 ischaracterized in that the generation of an update after parity record108 is made in asynchronism with a data transfer process of the controlunit 1305. Namely, FIG. 75 shows the operation of the control unit 1305in the first embodiment in the case where the parity generation timing dshown in FIG. 86 is used as a parity generation timing.

The control unit 1305 shown in FIG. 75 generates the update after parityrecord 108 from an update before data record 105, an update after datarecord 106 and an update before parity record 107 by use of a paritygeneration part a 7501 (in conjunction with data lines 7504). Sinceprocess parts other than a hit/miss judge part j 7500, an asynchronousrecord load part f 7502 and the parity generation part a 7501 havealready been described, explanation thereof will be omitted.

a) Hit/Miss Judge Part j 7500

FIG. 79 shows the flow chart of a process performed by the hit/missjudge part j 7500 shown in FIG. 75. The hit/miss judge part j 7500 hasthree execution start points. A first start point is a start point ashown in FIG. 79 or a start point at which the execution is started whena write request from the processor 1300 is received. A second startpoint is a start point b shown in FIG. 79 or a start point at which theexecution is started when a process by the synchronous data load part a102 is completed. A third start point is a start point when the releasefrom a wait condition is made. The flow of a process performed inconjunction with the third start point is similar to that of thehit/miss judge part a 100 shown in FIG. 27. Since the process flow ofthe hit/miss judge part j 7500 shown in FIG. 79 is approximately thesame as that of the hit/miss judge part a 100 shown in FIG. 26,processings in FIG. 79 corresponding to those shown in FIG. 26 aredesignated by the same step numbers as those used in FIG. 26 and thedifference from FIG. 26 will be explained here. Namely, in the casewhere the result of check in step 2607 as to whether or not there is anyone among update before parity records 107 which does not exist in acache 1308 indicates that all records 107 exist in the cache 1308, thecontrol unit 1305 turns on a parity generation bit 2206 in step 7900 andthereafter transfers the process to step 2609.

b) Asynchronous Record Load Part f 7502

FIG. 83 shows the flow chart of a process performed by the asynchronousrecord load part f 7502 shown in FIG. 75. This process is performed whena positioning process for a disk unit 1304 is completed. The flow of aprocess performed using a time when the control unit 1305 is idle, isthe same as that shown in FIG. 34. Since the process flow of theasynchronous record load part f 7502 shown in FIG. 83 is approximatelythe same as that of the asynchronous record load part a 103 shown inFIG. 35, processings in FIG. 83 similar to those shown in FIG. 35 aredesignated by the same step numbers as those used in FIG. 35 and thedifference from FIG. 35 will be explained here. Namely, in the casewhere load request bits become all OFF (in step 3500), the control unit105 turns on a parity generation bit 2206 in step 7900.

c) Parity Generation Part a 7501

FIG. 84 shows the flow chart of a process performed by the paritygeneration part a 7501 shown in FIG. 75.

In step 8400, the control unit 1305 refers to disk unit occupyinformation 2004 to search for disk units 104 which are empty. In step8401, the control unit 105 searches the searched-out empty disk units104 for PG management information 2001 in which a parity generation bit2206 is ON and lock information 2204 is OFF, and turns on the lockinformation 2204.

In step 8402, the control unit 1305 generates an update after parityrecord 108 from an update before data record 105, an update after datarecord 106 and an update before parity record 107. In step 8403, thecontrol unit 1305 turns, the update after data record 106 correspondingto a data record 1500 made the object of write and all the update afterparity records 108, to an update before data record 105 and updatebefore parity records 107, respectively. A specific processing for thatpurpose is the same as that in step 3102 explained in conjunction withFIG. 31.

In step 8404, the control unit 1305 sets values into write after bits2202 corresponding to all the parity records 1501 and resets a paritygeneration bit 2206, lock information 2204 and disk unit occupyinformation 2004. Finally, in step 8405, the control unit 1305 refers tolock wait information 2205 and disk unit wait information 2005 torelease a read/write request from the processor 1300 which is in a waitcondition.

3. Second Embodiment

1) Outline

As shown in FIG. 87, a second embodiment is an embodiment in which theparity group hit/miss judge process a 6500 and the asynchronous processb 6900 are combined. The parity generation timings a to d are relevantto the second embodiment.

FIG. 4 shows the operation of a control unit 1305 in the secondembodiment in the case where an update before data record 105corresponding to a data record 1500 made the object of write and allupdate before parity records 107 in the corresponding parity group 1600exist in a cache 1308. Namely, FIG. 4 shows the operation of the controlunit 1305 in the second embodiment in the case where the paritygeneration timing a shown in FIG. 72 is used as a parity generationtiming.

In this case, when writing an update after data record 106 into thecache 1308 (and the nonvolatile memory 1400), the control unit 1305generates an update after parity record 108 by use of a synchronous datawrite part d 401. In the case where a reliable fast write process 1402is applied, the synchronous data write part d 401 has a function ofwriting data received from a processor 1300 into the nonvolatile memory1400 (in conjunction with a data line 402) though this function is notshown in FIG. 4.

The update after data record 106 and the update after parity record 108are written into disk units 1304 by use of an asynchronous record writepart a 103 (in conjunction with a data line 111) in asynchronism with aread/write request from the processor 1300.

FIG. 5 shows the operation of the control unit 1305 in the secondembodiment in the case where there is any one among an update beforedata record 105 of a data record 1500 made the object of write and allupdate before parity records 107 in the corresponding parity group 1600which does not exist in a cache 1308. Namely, FIG. 5 shows the operationof the control unit in the second embodiment in the case where theparity generation timing b shown in FIG. 73 is used as a paritygeneration timing. In this case, the control unit 1305 load, an updatedbefore data record 105 or an update before parity record 107 which doesnot exist in the cache 1308, into the cache 1308 by use of a synchronousrecord load part a 201 in asynchronism with a read/write request from aprocessor 1300. At a timing when the last data in the assembly or set ofan update before data record 105 and update before parity records 107which do not exist in the cache 1308 is transferred into the cache 1308,update after parity records 108 for all parity records 1501 aregenerated (in conjunction with a data line 203).

As shown in FIG. 5, an update after data record 106 is written into thecache 1308 by a synchronous data write part e 500 (in conjunction with adata line 501). However, at this timing, the update after parity record108 is not generated. The operation of an asynchronous record write parta 103 is similar to the operation of that shown in FIG. 4.

2) Details Of Processes

a) Hit/Miss Judge Part c 400

FIG. 43 shows the flow chart of a process performed by a hit/miss judgepart c 400. The flow chart shown in FIG. 43 illustrates the flow of aprocess performed when a write request is received from the processor1300. The flow of a process performed by the hit/miss judge part c 400when the release from a wait condition is made, is the same as theprocess flow shown in FIG. 27. The process flow of the hit/miss judgepart c 400 shown in FIG. 43 is approximately the same as that of thehit/miss judge part a 100 shown in FIG. 26. Therefore, processings inFIG. 43 corresponding to those shown in FIG. 26 are designated by thesame step numbers used in FIG. 26 and the difference from FIG. 26 willnow be explained here.

In step 4302, the control unit 1305 checks whether or not there is anyrecord among an update before data record 105 and all updates beforeparity records 107 in the corresponding parity group 1600 which does notexist in the cache 1308. In the case where all the above records existin the cache, the control unit 1305 calls the synchronous data writepart d 401 in step 4300, thereby completing the process. In the casewhere there is any record which does not exist in the cache, the controlunit 1305 calls the synchronous data write part e 500 in step 4301,thereby completing the process.

b) Synchronous Data Write Part d 401

FIG. 44 shows the flow chart of a process performed by the synchronousdata write part d 401. The flow chart shown in FIG. 44 illustrates theflow of a process performed by the synchronous data write part d 401when it is called by the hit/miss judge part c 400. The process flow ofthe synchronous data write part d 401 shown in FIG. 44 corresponds tothat of the synchronous data write part a 101 shown in FIGS. 30 and 31.Therefore, processings in FIG. 44 corresponding to those shown in FIGS.30 and 31 are designated by the same step numbers as those used in FIGS.30 and 31 and the difference from FIGS. 30 and 31 will now be explained.

In step 4400, the control unit 1305 ensures a segment 1800 for storingan update after data record 106. In step 4401, the control unit 1305ensures segments 1800 for storing all update after parity records 108.(In the case where the records are to be also stored into thenonvolatile memory 1400, nonvolatile segments 2500 are ensured in steps4400 and 4401.)

In step 4402, the control unit 1305 performs the following processings.

1 Data received form the processor 1300 is stored as an update afterdata record 106 into a segment 1800 indicated by an update after segmentpointer 2201.

2 All update after parity records 108 are generated from an updatebefore data record 105, the data received from the processor 1300 andall update before parity records 107, and the generated records 108 arestored into segments indicated by the corresponding update after segmentpointers 2201.

(In the case where the data are to be also stored into the nonvolatilememory 1400, the data are stored into nonvolatile segments 2500 in theabove processings 1 and 2.)

Further, in step 4403, the control unit 1305 sets values into writeafter bits 2202 corresponding to a data record 1500 for which a writerequest was accepted and all parity records 1501.

c) Synchronous Data Write Part e 500

FIG. 45 shows the flow chart of a process performed by the synchronousdata write part e 500. The flow chart shown in FIG. 45 illustrates theflow of a process performed by the synchronous data write part e 500 iscalled by the hit/miss judge part c 400. The process flow of thesynchronous data write part e 500 shown in FIG. 45 corresponds to thatof the synchronous data write part b 200 shown in FIGS. 32 and 33.Therefore, processings in FIG. 45 corresponding to those shown in FIGS.32 and 33 are designated by the same step numbers as those used in FIGS.32 and 33 and the difference from FIGS. 32 and 33 will now be explained.

In step 4500, the control unit 1305 ensures a segment 1800 for storingan update after data record 106. In step 4501, the control unit 1305stores data received from the processor 1300 into the segment 1800indicated by an update after segment pointer 2201 and turns on thecorresponding write after bit 2202. At this time, data in a segmentindicated by an update before segment pointer 2200 is held. The reasonhas already been mentioned in conjunction with the first embodiment. (Inthe case where the data is to be also stored into the nonvolatile memory1400, a nonvolatile segment 2500 is ensured in step 4500 and the data isstored into the nonvolatile segment 2500 in step 4501.)

In step 4502, in the case where the cache does not include therein anupdate before data record 105 of the data record 1500 for which thewrite request was accepted, and all the update before parity records107, the control unit 1305 sets the corresponding load request bit.

The processes performed by the other process parts or the asynchronousrecord load part a 201 and the asynchronous record write part a 103 arethe same as those shown and explained in conjunction with the firstembodiment.

3) Other Method 1 For Realization Of Second Embodiment

FIG. 6 is a block diagram for explaining another method 1 which realizesthe first embodiment. This method is different from the method shown inFIGS. 4 and 5 in that the timing of generation of an update after parityrecord 108 is a timing when the update after parity record 108 itself iswritten into a disk unit 1304. Namely, FIG. 6 shows the operation of thecontrol unit 1305 in the second embodiment in the case where the paritygeneration timing c shown in FIG. 74 is used as a parity generationtiming.

In FIG. 6 too, the control unit 1305 generates the update after parityrecord 108 by use of an asynchronous record write part b 302 (inconjunction with a data line 306) in a manner similar to that in thefirst embodiment shown in FIG. 3.

a) Hit/Miss Judge Part d 600

FIG. 46 shows the flow chart of a process performed by a hit/miss judgepart d 600. The flow chart shown in FIG. 46 illustrates the flow of aprocess performed when a write request from a processor 1300 isreceived. The flow of a process performed by the hit/miss judge part d600 when the release from a wait condition is made, is the same as thatshown in FIG. 27. Since the process flow of the hit/miss judge part d600 shown in FIG. 46 corresponds to that of the hit/miss judge part c400 shown in FIG. 43, processings in FIG. 46 corresponding to thoseshown in FIG. 43 are designated by the same step numbers as those usedin FIG. 43 and the difference from FIG. 43 will now be explained.

In step 4600, the control unit 4600 calls a synchronous data write partf 601 unconditionally in order to receive data for a data record 1500made the object of write from the processor 1300. The other processingsare the same as those shown in FIG. 43.

b) Synchronous data write part f 601

FIG. 47 shows the flow chart of a process performed by the synchronousdata write part f 601. The flow chart shown in FIG. 47 illustrates theflow of a process performed by the synchronous data write part f 601when it is called by the hit/miss judge part d 600. Since the processflow of the synchronous data write part f 601 shown in FIG. 47 isapproximately the same as that of the synchronous data write part e 500shown in FIG. 45, processings in FIG. 47 corresponding to those shown inFIG. 45 are designated by the same step numbers as those used in FIG. 45and the difference from FIG. 45 will now be explained.

In step 4700, the control unit 1305 checks whether nor not all updatebefore parity records 107 and an update before data record 105 arestored in the cache 1308. If there is any record 107 which is notstored, the flow jumps to step 4502. If all the records 107 are stored,the control unit 1305 turns on write after bits corresponding to all theupdate after parity records 107 in step 4701 and thereafter the flowgoes to the step 3303.

4) Other Method 2 for Realization of Second Embodiment

FIG. 76 is a block diagram for explaining still another method 2 whichrealizes the second embodiment. The method shown in FIG. 76 ischaracterized in that the generation of an update after parity record108 is made in asynchronism with a data transfer process of the controlunit 1305. Namely, FIG. 76 shows the operation of the control unit 1305in the second embodiment in the case where the parity generation timingd shown in FIG. 86 i used as a parity generation timing. As shown inFIG. 76, the control unit 1305 generates an update after parity record108 from an update before data record 105, an update after data record106 and an update before parity record 107 by use of a parity generationpart a 7501 (in conjunction with data lines 7504). Since process partsother than a hit/miss judge part k 7600 as mentioned hereinbelow havealready been described, explanation thereof will be omitted.

a) Hit/Miss Judge Part k 7600

FIG. 80 shows the flow chart of a process performed by a hit/miss judgepart k 7600. The hit/miss judge part k 7600 has two execution startpoints. A first start point is a start point shown in FIG. 80 or a startpoint at which the execution is started when a write request from theprocessor 1300 is received. A second start point is a start point whenthe release from a wait condition is made. The flow of a processperformed in conjunction with the second start is similar to that of thehit/miss judge part a 100 shown in FIG. 27.

The process flow of the hit/miss judge part k 7600 shown in FIG. 80corresponds to that of the hit/miss judge part a 100 shown in FIG. 26.Therefore, processings in FIG. 80 corresponding to those shown in FIG.26 are designated by the same step numbers as those used in FIG. 26 andthe difference from FIG. 26 will now be explained.

In step 4302, the control unit 1305 checks whether or not there is anyone among an update before data record 105 and an update before parityrecord 107 which does not exist in the cache 1308. In the case where allthe records exist, the control unit 1305 turns on a parity generationbit 2206 in step 7900 and thereafter the flow jumps to step 4301.

4. Third Embodiment

1) Outline

As shown in FIG. 87, a third embodiment is an embodiment in which theparity group hit/miss judge process b 6600 and the asynchronous processc 7000 are combined. The parity generation timings a to d are relevantto the third embodiment.

FIG. 7 shows the operation of a control unit 1305 in the thirdembodiment in the case where all in-group other data records 702 in aparity group 1600, to which a data record 1500 made the object of writebelongs, exist in a cache 1308. Namely, FIG. 7 shows the operation ofthe control unit 1305 in the third embodiment in the case where theparity generation timing a shown in FIG. 72 is used as a paritygeneration timing. In this case, when an update after data record 106 iswritten into a disk unit 1304, the control unit 1305 generates an updateafter parity record 108 by use of a synchronous data write part g 701(in conjunction with data lines 704). An updated value of a parityrecord 1501 is generated by a parity record generation unit b 703. Thecontrol unit 1305 writes the update after parity record 108 into a diskunit 1304 by use of an asynchronous record write part a 103 (inconjunction with a data line 111) in asynchronism with a read/writerequest from a processor 1300.

FIG. 8 shows the operation of the control unit 1305 in the thirdembodiment in the case where there is any one, among all in-group otherdata records 702 in a parity group 1600 to which a data record 1500 madethe object of write belongs, which does not exist in the cache 1308.Namely, FIG. 8 shows the operation of the control unit 1305 in the thirdembodiment in the case where the parity generation timing b shown inFIG. 73 is used as a parity generation timing. In this case, the controlunit 1305 loads the in-group other data record 702, which does not existin the cache 1308, into the cache 1308 by use of an asynchronous recordload part c 801 (in conjunction with a data line 803) in asynchronismwith a read/write request from the processor 1300. When the last one ofin-group other data records 702 which do not exist in the cache 1308 isloaded into the cache 1308, update after parity records 108 for allparity records 1501 are generated. As shown in FIG. 8, an update afterdata record 106 is written into a disk unit 1304 by use of a synchronousdata write part h 800 (in conjunction with a data line 802). However, atthis timing, the update after parity record 108 is not generated. Sincethe operation of an asynchronous record write part a 103 is similar tothe operation of that shown in FIG. 7, explanation thereof will beomitted.

2) Details of Processes

a) Hit/Miss Judge Part e 700

FIG. 48 shows the flow chart of a process performed by a hit/miss judgepart e 700. The flow chart shown in FIG. 48 illustrates the flow of aprocess performed when a write request from the processor 1300 isreceived. The flow of a process performed by the hit/miss judge part e700 when the release from a wait condition is made, is the same as theprocess flow shown in FIG. 27. The process flow of the hit/miss judgepart e 700 shown in FIG. 48 is approximately the same as that of thehit/miss judge part a 100 shown in FIG. 26. Therefore, processings inFIG. 48 corresponding to those shown in FIG. 26 are designated by thesame step numbers as those used in FIG. 26 and the difference from FIG.26 will now be explained.

In step 4800, the control unit 1305 checks whether or not there is anyone, among all in-group other data records 702 in a parity group 1600 towhich a data record 1500 made the object of write belongs, which doesnot exist in the cache 1308. In the case where all the records 702 existin the cache, the control unit 1305 calls the synchronous data writepart g 701 in step 4801, thereby completing the process. In the casewhere there is any record 702 which does not exist in the cache, thecontrol unit 1305 calls the synchronous data write part h 800 in step4802, thereby completing the process.

b) Synchronous Data Write Part g 701

FIG. 49 shows the flow chart of a process performed by the synchronousdata write part g 701 when a positioning process for a disk unit 1304 iscompleted. The flow of a process performed by the synchronous data writepart g 701 when it is called by the hit/miss judge part e 700, is thesame as the process flow shown in FIG. 30. The process flow of thesynchronous data write part g 701 shown in FIG. 49 is approximately thesame as that of the synchronous data write part a 101 shown in FIG. 31.Therefore, processings in FIG. 49 corresponding to those shown in FIG.31 are designated by the same step numbers as those shown in FIG. 31 andthe difference from FIG. 31 will now be explained.

In step 4900, the control unit 1305 writes data received from theprocessor 1300 into a disk unit 1304 and simultaneously therewithperforms the following actions:

1 storing the data received from the processor 1300 as an update afterdata record 106 into a segment 1800 indicated by an update after segmentpointer 2201; and

2 generating all update after parity records 108 from the update afterdata record 106 received from the processor 1300 and the other in-groupdata groups 702 in the group and storing the generated records 108 intosegments 1800 indicated by the corresponding update after segmentpointers 2201.

In step 4901, the control unit 1305 changes the values of update beforesegment pointers 2200 so as to indicate the segments 1800 having beenindicated by the update after segment pointers 2201 corresponding to thedata record 1500 made the object of write and all the parity records1501, and sets null values into the corresponding update after segmentpointers 2201. As a result, the update after data record 106 and theupdate after parity records 108 are turned to an update before datarecord 105 and update before parity records 107, respectively.

c) Synchronous Data Write Part h 800

FIG. 50 shows the flow chart of a process performed by the synchronousdata write part h 800. The flow chart shown in FIG. 50 illustrates theflow of a process performed when a positioning process for a disk unit,1304 is completed. The flow of a process performed by the synchronousdata write part h 800 when it is called by the hit/miss judge part e700, is the same as the process flow shown in FIG. 32. The process flowof the synchronous data write part h 800 shown in FIG. 50 isapproximately the same as that of the synchronous data write part b 200shown in FIG. 33. Therefore, processings in FIG. 50 corresponding tothose shown in FIG. 33 are designated by the same step numbers as thoseused in FIG. 33 and the difference from FIG. 33 will now be explained.

In step 5000, the control unit 1305 turns on lock request bitscorresponding to in-group other data records 702 which are not in thesame cache 1308. (In the case where a load request bit corresponding toa data record 1500 made the object of write is ON, the bit is turnedoff.)

d) Asynchronous Record Load Part c 801

FIG. 51 shows the flow chart of a process performed by the asynchronousrecord load part c 801 when a positioning process for a disk unit 1304is completed. The flow of a process performed using a time when thecontrol unit 1305 is idle, is the same as the process flow shown in FIG.34. The process flow of the asynchronous record load part c 801 shown inFIG. 51 is approximately the same as that of the asynchronous recordload part a 201 shown in FIG. 35. Therefore, processings in FIG. 51corresponding to those shown in FIG. 35 are designated by the same stepnumbers as those used in FIG. 35 and the difference from FIG. 35 willnow be explained.

In the case where load request bits 2203 in PG management information2001 become all OFF by the corresponding load process (in step 3500),the following processings are performed at this timing in order togenerate update after parity records 108 for all parity records 1501.

In step 5100, the control unit 1305 searches for segments 1800corresponding to all data records 1500 to which the corresponding paritygroup 1600 belongs and which are ones other than a data record 1500 madethe object of a load process.

In step 5101, the control unit 1305 performs the following operationwhile loading the parity record 1501 into a segment 1800 indicated by anupdate before segment pointer 2200. Namely, the control unit 1305generates update after parity records 108 for all parity records 1501 byuse of the parity generation unit b 703 from the data records 1500searched out in step 5100 and data records 1500 being loaded. Thegenerated parity records 108 are stored into segments indicated by thecorresponding update after segment pointers 2201.

In step 5102, the control unit 1305 changes update before segmentpointers 2200 so as to indicate the segments 1800 having been indicatedby the update after segment pointers 2201 corresponding to the datarecord 1500 made the object of write and all the parity records 1501,and sets null values into the corresponding update after segmentpointers 2201. As a result, the update after data record 106 and theupdate after parity records 108 are turned off to an update before datarecord 106 and update before parity records 107.

The asynchronous record write part a 103 has already been explained.

3) Other Method 1 for Realization of Third Embodiment

FIG. 9 is a block diagram for explaining another method 1 which realizesthe third embodiment. The method shown in FIG. 9 is different from themethod shown in FIGS. 7 and 8 in that the timing of generation of anupdate after parity record 108 is a timing when the update after parityrecord 108 itself is written into a disk unit 1304 (in conjunction witha data line 906). Namely, FIG. 9 shows the operation of the control unit1305 in the third embodiment in the case where the parity generationtiming c shown in FIG. 74 is used as a parity generation timing.

In FIG. 9 too, by use of an asynchronous record write part c 903, thecontrol unit 1305 generates the update after parity record 108 and inparallel therewith writes the generated record 108 into the disk unit1304 in a manner similar to that in the first embodiment shown in FIG.3. Accordingly, a synchronous data write part i 901 and an asynchronousrecord load part d 902 have no function of generating the update afterparity record 108.

a) Hit/Miss Judge Part f 900

FIG. 52 shows the flow chart of a process performed by a hit/miss judgepart f 900. The flow chart shown in FIG. 52 illustrates the flow of aprocess performed when a write request from the processor 1300 isreceived. The flow of a process performed by the hit/miss judge part f900 when the release from a wait condition is made, is the same as theprocess flow shown in FIG. 27. The process flow of the hit/miss judgepart f 900 shown in FIG. 52 is approximately the same as that of thehit/miss judge part b 300 shown in FIG. 38. Therefore, processings inFIG. 52 corresponding to those shown in FIG. 38 are designated by thesame step numbers used in FIG. 38 and the difference from FIG. 38 willnow be explained.

In step 5200, the control unit 1305 calls the synchronous data writepart i 901 unconditionally in order to receive data for a data record1500 made the object of write from the processor 1300.

b) Synchronous Data Write Part i 901

FIG. 53 shows the flow chart of a process performed by the synchronousdata write part i 901 when a positioning process for a disk unit 1304 iscompleted. The flow of a process performed by the synchronous data writepart i 901 when it is called by the hit/miss judge part f 900, is thesame as the process part shown in FIG. 32. The process flow of thesynchronous data write part i 901 shown in FIG. 53 is approximately thesame as that of the synchronous data write part h 800 shown in FIG. 50.Therefore, processings in FIG. 53 corresponding to those shown in FIG.50 are designated by the same step numbers as those used in FIG. 50 andthe difference from FIG. 50 will now be explained.

In step 5300, the control unit 1305 checks whether or not in-group otherdata records 702 (or other data records 1500) are stored in the cache1308. In the case where there is any record which is not stored inin-group other records in the cache, the flow jumps to step 5000. In thecase where all the records are stored in the cache, the control unit1305 turns on write after bits 2202 corresponding to all update beforeparity records 107 (step 5301) and thereafter the flow jumps to step3303.

c) Asynchronous Record Load Part d 902

FIG. 54 shows the flow chart of a process performed by the synchronousdata write part d 902 when a positioning process for a disk units 1304is completed. The flow of a process performed using a time when thecontrol unit 1305 is idle, is the same as the process flow shown in FIG.34. The process flow of the asynchronous record load part d 902 shown inFIG. 54 corresponds to one in which the processing for generating theupdate after parity record 108 is removed from the process flow of theasynchronous record load part c 801 shown in FIG. 51.

d) Asynchronous Record Load Part c 903

FIG. 55 shows the flow chart of a process performed by the asynchronousrecord load part c 903. The flow of a process performed using a timewhen the control unit 1305 is idle, is the same as the process flowshown in FIG. 41. The process flow of the asynchronous record load partc 903 shown in FIG. 55 is approximately the same as that of theasynchronous record write part b 302 shown in FIG. 42. Therefore,processings in FIG. 55 corresponding to those shown in FIG. 42 aredesignated by the same step numbers as those used in FIG. 42 and thedifference from FIG. 42 will now be explained.

In step 5500, the control unit 1305 performs the following processing.Namely, the control unit 1305 generates by use of a parity generationunit b 703 an update after parity record 108 from all data records 1500in the cache belonging to a parity group 1600 and in parallel therewithwrites the record 108 into a disk unit 1304. (A concrete way forselection of data records 1500 in the cache 1308 is the same as thatmentioned in conjunction with step 5100.) Further, the record 108 isstored into a segment 1800 indicated by an update after segment pointer2201.

In the case where write after bits 2202 become all OFF, the control unit1305 changes update before segment pointers 2200 so as to indicate thesegments 1800 having been indicated by the update after segment pointers2200 corresponding to a data record 1500 made the object of write andall parity records 1501, and sets null values into the correspondingupdate after segment pointers 2201 (step 5501).

4) Other Method 2 for Realization of Third Embodiment

FIG. 77 is a block diagram for explaining still another method 2 whichrealizes the third embodiment. The method shown in FIG. 77 ischaracterized in that the generation of an update after parity record108 is made in asynchronism with a data transfer process of the controlunit 1305. Namely, FIG. 77 shows the operation of the control unit 1305in the third embodiment in the case where the parity generation timing dshown in FIG. 86 is used as a parity generation timing.

As shown in FIG. 77, the control unit 1305 generates an update afterparity record 108 from an update after data record 106 and in-groupother data records 702 by use of a parity generation unit b 703 and aparity generation part b 7701 (in conjunction with data lines 7702).

a) Hit/Miss Judge Part l 7700

FIG. 81 shows the flow chart of a process performed by a hit/miss judgepart l 7700. The hit/miss judge part l 7700 has two execution startpoints. A first start point is a start point shown in FIG. 81 or a startpoint at which the execution is started when a write request from theprocessor 1300 is received. A second start point is a start point whenthe release from a wait condition is made. The flow of a processperformed in conjunction with the second start point is the same as theprocess flow of the hit/miss judge part a 100 shown in FIG. 27. Theprocess flow of the hit/miss judge part l 7700 shown in FIG. 81 isapproximately the same as that of the hit/miss judge part a 100 shown inFIG. 26. Therefore, processings in FIG. 81 corresponding to those shownin FIG. 26 are designated by the same step numbers as those used in FIG.26 and the difference from FIG. 26 will now be explained.

In step 4800, the control unit 1305 checks whether or not there is anyone among in-group other data records 1500 in a parity group 1600 whichdoes not exist in the cache 1308. In the case where all the recordsexist, the control unit 1305 turns on a parity generation bit 2206 instep 7900 and thereafter the flow jumps to step 4802.

b) Parity Generation Part b 7701

FIG. 85 shows the flow chart of a process performed by the paritygeneration part b 7701. The process flow of the parity generation part b7701 shown in FIG. 85 is approximately the same as that of the paritygeneration part a 7501 shown in FIG. 84. Therefore, processings in FIG.85 corresponding to those shown in FIG. 84 are designated by the samestep numbers as those used in FIG. 84 and the difference from FIG. 84will be explained here. Namely, in step 8500, the control unit 1305generates an update after parity record 108 from an update after datarecord 106 and in-group other data records 702.

5. Fourth Embodiment

1) Outline

As shown in FIG. 87, a fourth embodiment is an embodiment in which theparity group hit/miss judge process b 6600 and the asynchronous processd 7000 are combined. The parity generation timings a to d are relevantto the fourth embodiment.

FIG. 10 shows the operation of a control unit 1305 in the fourthembodiment in the case where all in-group other data records 702 in aparity group 1600, to which a data record 1500 made the object of writebelongs, exist in a cache 1308. Namely, FIG. 10 shows the operation ofthe control unit 1305 in the fourth embodiment in the case where theparity generation timing a shown in FIG. 72 is used as a paritygeneration timing.

In this case, when an update after data record 106 is written into adisk unit 1308, the control unit 1305 generates an update after parityrecord 108 by use of a synchronous data write part j 1001 (inconjunction with data lines 1002). A this time, a parity generation unitb 703 is used.

The control unit 1305 writes the update after data record 106 and theupdate after parity record 108 into disk units 1304 by use of anasynchronous record write part a 103 (in conjunction with a data line111) in asynchronism with a read/write request from a processor 1300.

FIG. 11 shows the operation of the control unit 1305 in the fourthembodiment in the case where any one, among all in-group other datagroups 702 in a parity group 1600 to which a data record 1500 made theobject of write belongs, does not exist in the cache 1308. Namely, FIG.11 shows the operation of the control unit 1305 in the fourth embodimentthe case where the parity generation timing b shows in FIG. 73 is usedas a parity generation timing.

In this case, the control unit 1305 loads the in-group other datarecords 702 which do not exist in the cache 1308, into the cache 1308 byuse of an asynchronous record load part c 802 in asynchronism with aread/write command from the processor 1300. When the last one ofin-group other data records 702 which do not exist in the cache 1308 isloaded into the cache 1308, the control unit 1305 generates update afterparity records 108 for all parity records 1501 (in conjunction with adata line 804).

As shown in FIG. 11, an update after data record 106 is written into thecache 108 by a synchronous data write k 1100 (in conjunction with a dataline 1101). (There may be the case where the record 106 is also writteninto a nonvolatile memory 1400.) However, at this timing, the updateafter parity record 108 is not generated. The operation of anasynchronous record write part a 103 is the same as the operation ofthat shown in FIG. 10.

2) Details of Processes

a) Hit/Miss Judge Part g 1000

FIG. 56 shows the flow chart of a process performed by a hit/miss judgepart g 1000. The flow chart shown in FIG. 56 illustrates the flow of aprocess performed when a write request from the processor 1300 isreceived. The flow of a process performed by the hit/miss judge part c1000 when the release from a wait condition is made, is the same as theprocess flow shown in FIG. 27. The process flow of the hit/miss judgepart c 1000 shown in FIG. 56 is approximately the same as that of thehit/miss judge part e 700 shown in FIG. 48. Therefore, processings inFIG. 56 corresponding to those shown in FIG. 48 are designated by thesame step numbers as those used in FIG. 48 and the difference from FIG.48 will now be explained.

In the case where all in-group other data records 702 in a parity group1600, to which a data record 1500 made the object of write belongs,exist in the cache 1308 (step 4800), the control unit 1305 calls thesynchronous data write part j 1001 in step 5600, thereby completing theprocess. In the case where there is any record 702 which does not existin the cache 1308, the control unit 1305 calls the synchronous datawrite part k 1100 in step 5601, thereby completing the process.

b) Synchronous Data Write Part j 1001

FIG. 57 shows the flow chart of a process performed by the synchronousdata write part j 1001. The flow chart shown in FIG. 57 illustrates theflow of a process performed by the synchronous data write part j 1001when it is called by the hit/miss judge part g 1000. The process flow ofthe synchronous data write part j 1001 shown in FIG. 57 is approximatelythe same as that of the synchronous data write part d 401 shown in FIG.44. Therefore, processings in FIG. 57 corresponding to those shown inFIG. 44 are designated by the same step numbers as those used in FIG. 44and the difference from FIG. 44 will now be explained.

In step 5700, the control unit 1305 stores data received from theprocessor 1300 as an update after data record 106 into a segment 1800indicated by an update after segment pointer 2201. In the case where thedata is to be stored in a nonvolatile memory 1400, the data is alsotransferred to a nonvolatile segment 2500. Further, the control unit1305 generates all update after parity records 108 from the update afterdata record 106 received from the processor 1300 and in-group other datarecords 702 and stores the generated records 108 into segments 1800indicated by the corresponding update after segment pointers 2201.

In step 5701, the control unit 1305 changes update before segmentpointers 2200 so as to indicate the segments 1800 having been indicatedby the update after segment pointers corresponding to the data record1500 made the object of write and all the parity records 1501, and setsnull values into the corresponding update after segment pointers 2201.

c) Synchronous Data Write Part k 1100

FIG. 58 shows the flow chart of a process performed by the synchronousdata write part k 1100. The flow chart shown in FIG. 58 illustrates theflow of a process performed by the synchronous data write part k 1100when it is called by the hit/miss judge part g 1000. The process flow ofthe synchronous data write part k 1100 shown in FIG. 58 is approximatelythe same as that of the synchronous data write part e 500 shown in FIG.45. Therefore, processings in FIG. 58 corresponding to those shown inFIG. 45 are designated by the same step numbers as those used in FIG. 45and the difference from FIG. 45 will now be explained.

In step 5800, the control unit 1305 turns on a load request bit 2203corresponding to in-group other data records 702 which are not stored inthe cache 1308.

The flow of processes performed by the other process parts of theasynchronous record load part c 802 and the asynchronous record writepart a 103 have already been explained.

3) Other Method 1 for Realization of Fourth Embodiment

FIG. 12 is a block diagram for explaining another method 1 whichrealizes the fourth embodiment. This method is different from the methodshown in FIGS. 10 and 11 in that the timing of generation of an updateafter parity record 108 is a timing when the update after parity record108 itself is written into a disk unit 1304. Namely, FIG. 12 shows theoperation of the control unit 1305 in the fourth embodiment in the casewhere the parity generation timing c shown in FIG. 74 is used as aparity generation timing.

In FIG. 12 too, by use of an asynchronous record write part b 903, thecontrol unit 1305 generates the update after parity record 108 and inparallel therewith writes the generated record 108 into the disk 1304(in conjunction with data lines 906) in a manner similar to that in thefirst embodiment shown in FIG. 3.

a) Hit/Miss Judge Part h 1200

FIG. 56 shows the flow chart of a process performed by a hit/miss judgepart h 1200. The flow chart shown in FIG. 59 illustrates the flow of aprocess performed when a write request from the processor 1300 isreceived. The flow of a process performed by the hit/miss judge part h1200 when the release from a wait condition is made, is the same as theprocess flow shown in FIG. 27. The process flow of the hit/miss judgepart h 1200 shown in FIG. 59 is approximately the same as that of thehit/miss judge part f 900 shown in FIG. 52. Therefore, processings inFIG. 59 corresponding to those shown in FIG. 52 are designated by thesame step numbers as those used in FIG. 52 and the difference from FIG.52 will now be explained.

In step 5900, the control unit 1305 calls the synchronous data writepart m 1201 unconditionally in order to receive data for a data record1500 made the object of write from the processor 1300.

b) Synchronous Data Write Part m 1201

FIG. 60 shows the flow chart of a process performed by the synchronousdata write part m 1201. The flow chart shown in FIG. 60 illustrates theflow of a process performed by the synchronous data write part m 1201when it is called by the hit/miss judge part h 1200. The process flow ofthe synchronous data write part m 1201 shown in FIG. 60 is approximatelythe same as that of the synchronous data write part k 1100 shown in FIG.58. Therefore, processings in FIG. 60 corresponding to those shown inFIG. 58 are designated by the same step numbers as those used in FIG. 58and the difference from FIG. 58 will now be explained.

In step 6000, the control unit 1305 checks whether all in-group otherdata records 702 are stored in the cache 1308. In there is any record702 which is not stored in the cache, the flow jumps to step 5800. Ifthe records 702 are in the cache 1308, the control unit 1305 turns onwrite after bits 2202 corresponding to all update before parity records107 (step 6001) and thereafter the flow jumps to step 3303.

The flows of processes performed by the other process parts or anasynchronous record load part d 902 and the asynchronous record writepart b 906 have already been explained.

4) Other Method 2 for Realization of Fourth Embodiment

FIG. 78 is a block diagram for explaining still another method 2 whichrealizes the fourth embodiment. The method shown in FIG. 78 ischaracterized in that the generation of an update after parity record108 is made in asynchronism with a data transfer process of the controlunit 1305. Namely, FIG. 78 shows the operation of the control unit 1305in the fourth embodiment in the case where the parity generation timingd shown in FIG. 86 is used as a parity generation timing.

As shown in FIG. 78, the control unit 1305 generates an update afterparity record 108 from an update after data record 106 and in-groupother data records 702 by use of a parity generation unit b 703 and aparity generation part b 7701 (in conjunction with data lines 7702).

a) Hit/Miss Judge Part m 7800

FIG. 82 shows the flow chart of a process performed by a hit/miss judgepart m 7800. The hit/miss judge part m 7800 has two execution startpoints. A first start point is a start point shown in FIG. 82 or a startpoint at which the execution is started when a write request from theprocessor is received. A second start point is a start point when therelease from a wait condition is made. The flow of a process performedin conjunction with the second start point is the same as the processflow of the hit/miss judge part a 100 shown in FIG. 27. The process flowof the hit/miss judge part m 7800 shown in FIG. 82 is approximately thesame as that of the hit/miss judge part g 1000 shown in FIG. 56.Therefore, processings in FIG. 82 corresponding to those shown in FIG.56 are designated by the same step numbers as those used in FIG. 56 andthe difference from FIG. 56 will now be explained.

In step 4800, the control unit 1305 checks whether or not there is anyone in other data records 1500 in a parity group 1600 which does notexist in the cache 1308. In the case where all the data records exist inthe cache, the control unit 1305 turns on a parity generation bit 2206in step 7900 and thereafter the flow goes to step 5602.

6. Fifth Embodiment

1) Outline

A fifth embodiment is an embodiment in which the parity group hit/missjudge process c 6700 is used. However, as shown in FIG. 87, the paritygroup hit/miss judge process a 6500, the parity group hit/miss judgeprocess b 6600, the asynchronous process a 6800, the asynchronousprocess b 6900, the asynchronous process c 7000, the asynchronousprocess d 7100 and the parity generation timings a to d are relevant tothe fifth embodiment.

As has already been mentioned, information necessary for generating anupdated value of a parity record 1501 includes one of the following sets1 and 2 of values:

1 the update before and update after values of a data record 1500 and anupdate before value of the parity record 1501; and

2 the update after value of the data record 1500 and the values of allother data records 1500 in the same parity group.

In the fifth embodiment, in generating the updated value of the parityrecord 1501, a control unit 1305 selects one of the above sets of valuesor records 1502 on the basis of the condition of storage of the records1502 in a cache 1308. FIG. 61 is a flow chart showing the operation ofthe control unit 1305 in the fifth embodiment.

2) Details of Process

When receiving a write request from a processor 1300, the control unit1305 checks the number of those records among update before parityrecords 107 and an update before data records 105 for a data record 1500made the object of write which do not exist in the cache 1308 (step6100).

In step 6101, the control unit 1305 checks the number of those recordsamong in-group other data records 702 (or other data records 1500) in aparity group including the data records 1500 made the object of writewhich do not exist in the cache 1308 (that is, the number of datarecords 1500 the update before and after segment pointers 2200 and 2201,each of which takes the null value.

In step 6102, the control unit 1305 checks which of the numbers ofrecords obtained in steps 6100 and 6101 is small. If there are selectedrecords the number of which is smaller, the overhead is less since thenumber of records 1502 to be loaded is small.

Accordingly, in the case where the number obtained in step 6100 issmaller, the flow goes to step 6103 in order to generate an updatedvalue of a parity record 1501 from an update before value of the datarecord 1500 made the object of write and update before values of theparity records 1501. The execution of the parity group hit/miss judgeprocess a 6500 is started from step 6103.

On the other hand, in the case where the number obtained in step 1600 isnot smaller, the flow goes to step 6106 in order to generate the updatedvalue of the parity record 1501 from the values of all the other datarecords 1500. The reaction of the parity group hit/miss judge process b6600 is started from step 6106.

In step 6103, the judgement is made as to whether or not the write ofthe data record 1500 into a disk unit should be synchronized. In thecase where the synchronization is made, there results in the selectionof the asynchronous process a 6800. In step 6104, the hit/miss judgepart a 100 is called. Calling the hit/miss judge part a 100 means thatthe parity generation timing a or b is selected as a parity generationtiming. In this case, if the parity generation timing c or d is to beselected, the hit/miss judge part b 300 or j 7900 may be called in lieuof the hit/miss judge part a 100.

In the case where the asynchronization is made, there results in theselection of the asynchronous data process b 6900. In step 6105, thehit/miss judge part c 400 is called. Calling the hit/miss judge part c400 means that the parity generation timing a or b is selected as aparity generation timing. In this case, if the parity generation timingc or d is to be selected, the hit/miss judge part d 600 or k 8000 may becalled in lieu of the hit/miss judge part c 400.

In step 6106, the judgement is made as to whether or not the write ofthe data record 1500 into a disk unit should be synchronized. In thecase where the synchronization is made, there results in the selectionof the asynchronous process c 7000. In step 6107, the hit/miss judgepart e 700 is called. Calling the hit/miss judge part e 700 means thatthe parity generation timing a or b is selected as a parity generationtiming. In this case, if the parity generation timing c or d is to beselected, the hit/miss judge part f 900 or l 7000 may be called in lieuof the hit/miss judge part e 700.

In the case where the asynchronization is made, there results in theselection of the asyncronous process d 7100. In step 6105, the hit/missjudge part g 1000 is called. Calling the hit/miss judge part g 1000means that the parity generation timing a or b is selected as a paritygeneration timing. In this case, if the parity generation timing c or dis to be selected, the hit/miss judge part h 1200 or m 8100 may becalled in lieu of the hit/miss judge part g 1000.

According to the present invention, a process for a write request issuedfrom a processor in a disk array using the data distribution by record(or a disk array in levels 4 and 5 in the Patterson et al' article) canbe performed at high speed. Namely, by using a disk cache in a controlunit, the shortening of a response time seen from the processor can berealized by

(1) shortening a process time for acquisition of information necessaryfor generating an updated value of a parity record and

(2) asynchronizing processes generated attendant upon a write request asgreat as possible.

What is claimed is:
 1. A storage system comprising: a plurality of diskunits storing data of a record group, said record group including aplurality of data records and a parity record that has redundant datafor recovering data of said plurality of data records, wherein data ofeach of said parity record and said plurality of data records is storedin a different one of said plurality of disk units; a cache memory; anda control unit, wherein said control unit receives a write request andwrite data to be written into one of said plurality of disk units from aprocessing unit coupled to said storage system, stores said write datainto said cache memory, and reports the completion of said write requestto said processing unit, and after reporting the completion of saidwrite request, said control unit checks whether or not data of recordsnecessary for generating updated value of said parity record is storedin said cache memory, loads data of one or plurality of recordsnecessary for generating the updated value of said parity record whenthe data of said one or plurality of records is not stored in said cachememory, generates the updated value of said parity record, writes theupdated value of said parity record to one of said plurality of diskunits which stores data of said parity record, and writes said writedata to one of said plurality disk units.
 2. A storage system accordingto claim 1, wherein said data of records necessary for generatingupdated value of said parity record are data of one of said plurality ofdata records which is to be updated by said write data and data of saidparity record.
 3. A storage system according to claim 2, wherein saidcontrol unit stores said write data into a region other than a region insaid cache memory where data of one of said plurality of data recordswhich is to be updated by said write data is stored.
 4. A storage systemaccording to claim 1, wherein said data of records necessary forgenerating updated value of said parity record is data of all of saidplurality of data records other than one of said plurality of datarecord where data updating by said write data is stored.
 5. A storagesystem comprising: a plurality of disk units storing data of a recordgroup, said record group including a plurality of data records and aparity record that has redundant data for recovering data of saidplurality of data records, wherein data of each of said parity recordand said plurality of data records is stored in a different one of saidplurality of disk units; a cache memory; and a control unit, whereinsaid control unit receives a write request and write data for updatingone of said plurality of data records from a central processing unit,stores said write data into said cache memory and one of said pluralityof disk units, and reports the completion of said write request to saidcentral processing unit, and after reporting the completion of saidwrite request, said control unit confirms whether or not data of recordsnecessary for generating updated value of said parity record is storedin said cache memory, loads data of one or plurality of recordsnecessary for generating the updated value of said parity record whichis not stored in said cache memory, generates the updated value of saidparity record, and writes the updated value of said parity record to oneof said plurality of disk units.
 6. A storage system according to claim5, wherein said data of records necessary for generating updated valueof said parity record are data of one of said plurality of data recordswhich is to be updated by said write data and data of said parityrecord.
 7. A storage system according to claim 5, wherein said data ofrecords necessary for generating updated value of said parity record isdata of all of said plurality of data records other than one of saidplurality of data record where data updating by said write data isstored.